Key Takeaways

  • Software teams do not need a fully automated dark factory to benefit from AI; Lean manufacturing demonstrates that core principles hold true across environments while practices must shift based on constraints.
  • Individual developer productivity stalls at the team boundary unless groups move tribal prompt knowledge into shared codebase infrastructure.
  • Speed without safety creates compounding defects; Andrew Dunlap showed that changing scale requires slowing down for verification before accelerating velocity.
  • Unchecked upstream AI code generation turns standard review steps into crippling operational bottlenecks.
  • Engineering organizations need SEP's 5 Principles for AI Software Engineering Teams to move from fragmented personal experiments to disciplined production delivery.

The SEP's 5 Principles for AI Software Engineering Teams

Founders often assume AI software development means building toward a lights-out dark factory where human engineers vanish completely. Chris Shinkle and Andrew Dunlap from SEP reject that premise. At the second annual Midwest AI Summit, Shinkle pointed back to Toyota and classic manufacturing: “Lean first off would say there's no single blueprint, there's no one right answer for everybody. Again, reason why you don't all need the dark factory.”

For Shinkle, the distinction between enduring rules and temporary tactics is absolute: “Principles, think about this, are true everywhere, the practices aren't. The practices will vary depending on your, like Andrew said, your constraints.”

To turn sporadic prompt experiments into predictable engineering, Dunlap and Shinkle laid out five operational principles:

Principle 1: Shared Infrastructure

Establish a centralized body of knowledge within the codebase containing architecture decisions, domain elements, coding rules, and workflow plans so all developers and agents operate from identical context. As Dunlap noted, “We went from individual to shared. We started pulling the knowledge into the code base so everyone had access to it: shared infrastructure.”

Principle 2: Deliberate Iteration

Schedule recurring, dedicated team time each week to explicitly review AI model performance, tool friction, and audit noise to continuously improve team-wide AI workflows.

Principle 3: Make It Safe (Verification Before Velocity)

Prioritize automated verification and output correctness before accelerating development speed, especially when scaling from single prototypes to production parameter spaces. Dunlap recalled of SEP's own work: “We slowed down, that's because the scale changed, the constraints changed, and we needed to make sure that we were getting the right answer before we went fast.”

Principle 4: Chase Systematic Bottlenecks

Continuously identify and eliminate workflow bottlenecks, such as code review backlogs, which become severely amplified once AI increases generation volume upstream.

Principle 5: Remove the Toil

Deterministically script repetitive, mechanical tasks in code, reserving human cognitive capacity for intent and high-level reasoning, and directing LLMs toward analytical and generative tasks. In Dunlap's words: “Script the things that happen over and over again, save the thinking for the humans, save the analytical processes for the LLMs.”

When This Works (and When It Doesn't)

This framework excels when engineering leaders need to scale AI across multi-developer teams operating under real-world quality, reliability, and regulatory constraints. When several developers generate code simultaneously, individual prompt habits create fragmented patterns. Centralizing repository context and enforcing automated verification stops silent drift before code hits production.

It breaks down for a solo hacker prototyping a throwaway proof of concept in a weekend hackathon. If you have no users, no legacy architecture, and no teammates waiting on your pull requests, spending hours defining shared coding rules or scheduling formal iteration reviews adds overhead without value. You do not need Lean bottleneck analysis until you have an actual production pipeline to constrain.

What to Do With This

Audit your team's pull request queue tomorrow morning. If your engineers use AI assistants to generate code twice as fast, but pull requests sit unreviewed for two days, you have not accelerated shipping; you have merely created an upstream inventory pileup.

Take three steps this week to fix the pipeline:

First, create a repository context file containing your top five architectural conventions and domain definitions so every developer's assistant generates aligned code.

Second, write deterministic test scripts to run on every commit so verification happens instantly instead of during human review.

Third, block thirty minutes this Friday to review tooling friction and noisy model suggestions with your entire team.