← Back

AI-Driven Development

Code Is Cheap, Trust Is Expensive

AI makes code generation fast and cheap. The bottleneck moved from writing code to reviewing, testing, and trusting changes. Speed gain is smaller than expected when only one part of the pipeline accelerates.

  • Humans carry all consequences — bugs, security issues, regressions.
  • More code is not more progress. It is more liability.
  • Shadow accidental complexity: AI generates code that looks clean and passes linters but adds surface area humans must carry.

Two Kinds of Complexity

  • Essential complexity: business rules, edge cases, domain boundaries. No tool removes it.
  • Accidental complexity: inconsistent patterns, boilerplate, architecture friction. Rules and conventions fix it.

When accidental exceeds essential, the team stops solving business problems. AI makes the accidental side so easy that teams skip the essential side — generating code before understanding the domain creates systems that are well-written but wrong.

Conventions Are the Foundation

Without conventions, AI amplifies existing mess. Each generation drifts. Same problem solved three different ways across files.

  • Define architecture conventions in files AI can read — project instructions (CLAUDE.md), rules files, custom skills.
  • Framework and tooling choices should favor what AI tools know well. Popular, well-documented frameworks produce better AI output.
  • With conventions, AI reduces accidental complexity at scale. The difference is not the AI. The difference is the constraints you give it.

The Engineer as Architect

Engineers should be architects. The role shifts from code producer to architect-reviewer.

  • Humans own essential complexity: business logic, architecture, tradeoffs, boundary design.
  • AI handles accidental complexity: boilerplate, scaffolding, repetitive patterns, convention enforcement.
  • For essential complexity, AI serves as a thinking partner — explore tradeoffs, challenge assumptions. But the judgment stays human.
  • AI can skip domain thinking and produce well-written code that is conceptually wrong.

Structure Enables Trust

Structure is a safety mechanism, not aesthetics. Vertical slices with strict dependency rules enable quick answers to “what does this change affect?”

  • Module ownership, reduced change amplification, and clear public APIs make AI-generated code trustable at scale.
  • Tests shift from catching bugs to defining correctness. They become the contract between past and future changes.
  • Quality moves earlier in the process. If validation happens late, the system chokes.

Documentation as Context

Keep documentation in the code. AI tools can read and understand decisions in context. External wikis AI cannot access are wasted context.

  • Why a decision was made, what constraints exist, what success looks like — this is what AI and humans both need.
  • Product-engineering collaboration happens before AI writes code, not after.

Evolution

  • Feb 2026 — rewritten in rule-oriented format from accidental complexity article, trust article, and IDENTITY.md.