home / skills / refoundai / lenny-skills / engineering-culture

engineering-culture skill

/skills/engineering-culture

This skill helps you build a high-performing engineering culture by diagnosing bottlenecks, balancing structure and autonomy, and aligning DevEx with outcomes.

npx playbooks add skill refoundai/lenny-skills --skill engineering-culture

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
4.5 KB
---
name: engineering-culture
description: Help users build strong engineering culture. Use when someone is improving developer experience, fostering technical excellence, designing engineering practices, or scaling an engineering organization.
---

# Engineering Culture

Help the user build strong engineering culture using frameworks from 19 product leaders who have built high-performing engineering organizations.

## How to Help

When the user asks for help with engineering culture:

1. **Diagnose the current state** - Understand their team size, practices, and pain points
2. **Identify the bottleneck** - Determine if the issue is DevEx, org structure, talent, or process
3. **Design for the right outcomes** - Focus on speed, stability, and developer satisfaction
4. **Balance structure with autonomy** - Help calibrate how much process is needed

## Core Principles

### DevOps is capabilities, not tools
Nicole Forsgren: "DevOps is not a toolchain you buy. Marketing teams labeled toolchains DevOps because they wanted your money. DevOps is a set of capabilities - technical capabilities, architectural capabilities, cultural capabilities, and lean management practices." Focus on integrated capabilities, not just implementing specific tools.

### Conway's Law is powerful
Dhanji R. Prasanna: "Conway's Law can be really, really powerful. You ship your org structure. What you're organized as in terms of teams and collaborating groups matters a lot to what you build." Organizational structure directly dictates architecture and product quality.

### Engineers are becoming architects
Scott Wu: "We've thought about Devin as really allowing engineers to go from bricklayer to architect. A lot of it is just getting to the point where you can do the high-level directing and specify things exactly how you want." The future of engineering involves shifting humans from manual coding to architectural oversight.

### DevEx is the foundation
Nicole Forsgren: "Developer Experience is what it's like to build software, day to day. The friction they face, the workflows they have to go through. It's important because when DevEx is poor, everything else just isn't going to help." Flow state, cognitive load, and feedback loops are the three pillars.

### Optimize for clock speed
Albert Cheng: "The product experience of Duolingo actually changes multiple times per day for each user. They care a lot about the clock speed of the company." High-performance engineering culture is built around extreme experimentation frequency.

### Require all functions to touch code
Brandon Chu: "All project management was just in GitHub, just commenting on PRs, and even marketers in order to upload a blog post, you'd have to commit and deploy it." Build technical culture by requiring all functions to engage directly with engineering tools.

### High talent density reduces process need
Michael Truell: "We've been able to get away with not a ton of process yet on the engineering front by hiring people who are really excellent, level-headed, people who are less focused on external validation, more focused on building something really great." Hire for disposition to reduce organizational overhead.

### Pair programming is underutilized
Farhan Thawar: "Pair programming is the most underutilized management tool in engineering, bar none. The throughput limiter is not hands-on keyboard. It's where is the good elegant solution?" Use pairing for knowledge transfer and finding elegant solutions.

## Questions to Help Users

- "What's the biggest friction point in your developers' daily workflow?"
- "How does your org structure map to your product architecture?"
- "How much time do engineers spend in flow state vs in meetings?"
- "What's your team's 'clock speed' - how often can you ship and test changes?"
- "Do non-engineering roles understand the deployment workflow?"

## Common Mistakes to Flag

- **Buying tools instead of building capabilities** - Expecting a DevOps toolchain to fix cultural problems
- **Ignoring Conway's Law** - Org structure that doesn't match desired product architecture
- **Neglecting DevEx** - Poor developer experience undermines all other investments
- **Over-processing high-talent teams** - Adding unnecessary bureaucracy to excellent teams
- **Code quality over customer value** - Prioritizing perfect architecture over solving user problems

## Deep Dive

For all 23 insights from 19 guests, see `references/guest-insights.md`

## Related Skills

- Technical Roadmaps
- Managing Tech Debt
- Platform & Infrastructure
- Design Engineering

Overview

This skill helps leaders and managers build a strong engineering culture by applying battle-tested frameworks from product and engineering leaders. It focuses on diagnosing current problems, identifying bottlenecks, and designing practical changes that improve developer experience, delivery speed, and technical quality. Use it to translate cultural goals into measurable practices and org design choices.

How this skill works

I start by diagnosing the current state: team size, workflows, pain points, and delivery metrics. Then I identify the primary bottleneck—developer experience, org structure, talent, or process—and recommend targeted interventions. Advice emphasizes capabilities over tools, aligning org structure with product architecture, and balancing autonomy with necessary guardrails. Recommendations include concrete experiments, success metrics, and rollout steps.

When to use it

  • You’re improving developer experience (DevEx) and want concrete priorities
  • You’re scaling engineering and need to align org structure with architecture
  • You want to reduce cycle time and increase experimentation frequency
  • You’re setting up platform or DevOps capabilities, not just buying tools
  • You need to onboard non-engineering roles into technical workflows

Best practices

  • Treat DevOps as capabilities (people, architecture, processes), not just a toolchain
  • Map org structure to product architecture to avoid Conway’s Law mismatches
  • Measure and prioritize flow state, cognitive load, and feedback loop latency
  • Hire for high talent density to reduce process friction where possible
  • Use pair programming strategically for knowledge transfer and elegant solutions
  • Require cross-functional roles to touch code or the deployment workflow to build shared ownership

Example use cases

  • Run a 2-week diagnostic to find the biggest DevEx bottlenecks and propose three fixes
  • Design team boundaries so each team owns clear product surfaces and APIs, minimizing cross-team coupling
  • Create a low-friction experiment pipeline to increase clock speed and daily experimentation
  • Define platform capabilities roadmap that prioritizes developer flow and rapid feedback
  • Shift a high-talent team to fewer checks and more autonomy with lightweight guardrails

FAQ

How do I know whether to add process or hire more senior engineers?

Diagnose the root cause first: if failures stem from unclear ownership or coordination, add structure. If issues are execution quality or independent judgment, invest in higher talent density. Often a mix of small process shifts plus targeted hires works best.

Is buying a new DevOps toolset a good first step?

No—start by defining the capabilities you need (deploy safety, fast feedback, observability). Tools can help, but buying them without changing practices rarely fixes culture or flow problems.

How can I measure developer experience effectively?

Track cycle time, deployment frequency, mean time to restore, time spent in meetings vs flow, and qualitative developer surveys focused on friction points.