Skip to main content

​
The Promise vs The Reality

Everyone selling AI tools has the same pitch: “10x your productivity.” Code faster. Ship more. Build better. After 7 weeks of building a production SaaS platform with AI agents, processing 8,000+ lines of code across 524 commits, I have data. Real metrics. Actual time tracking. Here’s what I found: AI doesn’t make you 10x faster. It makes you fundamentally different. The total hours didn’t drop by 90%. They redistributed across different activities. And that redistribution matters more than raw speed. Let me show you what actually happened.

​
The Productivity Myth: What We Were Told

The narrative:
  • AI writes code instantly
  • You save 80-90% of your development time
  • Ship features in days instead of weeks
  • 10x productivity gains are typical
The implication:
  • Typing code was your bottleneck
  • Faster code generation = faster delivery
  • More lines per hour = more productivity
The uncomfortable question nobody asks: If AI saves 90% of coding time, why aren’t teams shipping 10x more features?

​
Where Time Actually Goes: The Real Distribution

I tracked every hour for 7 weeks. Here’s what changed:

​
Before AI (Traditional Development)

Time distribution:
  • 80% Implementation (writing code, debugging syntax)
  • 15% Design & Planning (architecture decisions, pattern selection)
  • 5% Code Review & Verification
What consumed time:
  • Typing boilerplate code
  • Fighting with the compiler
  • Writing repetitive tests
  • Searching documentation
  • Copy-pasting patterns
Bottleneck: Typing speed, context switching, repetitive work

​
With AI (AI-Assisted Development)

Time distribution:
  • 30% Prompt Crafting & Context Preparation
  • 40% Verification & Review (checking AI output, catching errors)
  • 30% Design & Architecture (forced upstream by prompting)
What consumed time:
  • Writing clear, unambiguous prompts
  • Preparing context (ADRs, requirements, examples)
  • Verifying AI didn’t hallucinate features
  • Catching cross-entity inconsistencies
  • Redesigning when AI misunderstood
Bottleneck: Clarity of thought, requirement precision, verification rigor Net time saved: ~20% (not 10x)

​
The Data: What Really Happened

Let’s look at real numbers from the 7-week journey:
The headline metric:
  • 4,000 lines of code in 3 days
  • “Looks like 10x productivity!”
What the metric hides:
  • 2 days writing ADR-0020 beforehand (architecture decisions)
  • 1 day of verification after (caught 6 bugs)
  • 3 hours of rework for missed edge cases
Actual timeline:
  • Planning: 16 hours (2 days)
  • Implementation: 24 hours (3 days)
  • Verification: 8 hours (1 day)
  • Total: 48 hours (6 days)
Manual estimate: 10-12 days for same featureActual productivity gain: 2x, not 10x

​
The Controversial Take: What Actually Changed

​
1. AI Makes Bad Developers Pattern-Match Faster

If your development workflow is:
  1. Copy code from StackOverflow
  2. Modify until it compiles
  3. Ship when tests pass
AI accelerates this. You’ll ship more code, faster. Congratulations, you’re now 10x faster at creating technical debt. Why: AI is the ultimate pattern-matcher. It excels at “code that looks right” even when the design is wrong.

​
2. AI Makes Good Developers Work Upstream

If your development workflow is:
  1. Understand the problem deeply
  2. Design the right abstraction
  3. Implement with intention
AI shifts your effort from implementation to design. You spend MORE time thinking, LESS time typing. The paradox: You type less code but spend MORE time on software engineering. The shift:
  • Before AI: 80% implementation, 20% design
  • With AI: 30% implementation, 70% design + verification
This isn’t “10x faster.” It’s “fundamentally different work.”

​
3. The 10x Myth Assumes Typing Was the Bottleneck (It Wasn’t)

The false assumption:
  • Developers spend most time typing code
  • Faster code generation = faster delivery
  • Lines of code per hour is the metric
The reality:
  • Typing was never the bottleneck
  • Understanding requirements was
  • Making the right design decisions was
  • Catching bugs before production was
What AI actually does:
  • Eliminates typing as a bottleneck (good!)
  • Exposes thinking as the real bottleneck (uncomfortable truth)
The uncomfortable implication: If typing wasn’t your bottleneck, AI won’t 10x you. It will reveal that you weren’t thinking deeply enough.

​
What AI Actually Does (The Real Value)

​
1. Amplifies Good Design Decisions

Example: Event-sourced macros (Week 3) Good design decision: 
#[derive(DomainAggregate, DomainEvent)]
#[capsule_isolated]
pub struct Lead { ... }
AI’s role:
  • Applied this pattern across 15 entities consistently
  • Generated 4,702 lines of boilerplate (94% reduction)
  • Zero isolation bugs after pattern established
The insight: AI can’t make good architectural decisions, but it can apply them perfectly. Result: 8-10x speedup on systematic implementation of a good design.

​
2. Accelerates Bad Design Decisions

Example: Cascading compilation errors (Week 3) Bad design decision: 
// Breaking change to macro signature
fn pk_for_id(self, id) -> String
AI’s role:
  • Attempted to fix cascading errors across 95 files
  • Each fix broke something else
  • 24 hours of failed attempts
  • Human completed it in 90 minutes
The insight: AI can’t see the system-wide implications of breaking changes. Result: 16x SLOWER than human on large refactorings.

​
3. Forces Clarity (The Context Forcing Function)

Before AI: Vague requirements were fine
  • “Make it user-friendly” → I’d figure it out while coding
  • “Handle edge cases” → I’d discover them during testing
  • “Follow best practices” → I’d use my judgment
With AI: Vague requirements produce garbage
  • “Make it user-friendly” → AI hallucinates features
  • “Handle edge cases” → AI invents edge cases that don’t exist
  • “Follow best practices” → AI copies patterns from training data
The forcing function: To get good AI output, you must:
  1. Write clear, unambiguous requirements
  2. Document architectural decisions (ADRs)
  3. Provide concrete examples
  4. Define success criteria explicitly
The unexpected benefit: This discipline improves your thinking even without AI. See The Lost Art of Mental Compilation for why deliberate thinking matters more than speed. Result: Better software design, regardless of whether AI implements it.

​
4. Redistributes Cognitive Load

Traditional development: 
[Design 15%] → [Implement 80%] → [Review 5%]
Bottleneck: Implementation fatigue Risk: Cut corners on design to start coding sooner AI-assisted development: 
[Design 30%] → [Implement 30%] → [Verify 40%]
Bottleneck: Design clarity, verification rigor Risk: Trust AI output without sufficient verification The shift:
  • Less time: Fighting syntax, writing boilerplate, repetitive testing
  • More time: Architectural decisions, requirement clarity, output verification
  • Different skill: Pattern recognition → System thinking
The controversial insight: AI reveals who was relying on implementation complexity to hide weak architectural thinking. When implementation is instant, design quality becomes the differentiator.

​
The Real 10x: Different Work Economics

AI didn’t make me 10x faster at the same work. It changed what work became economically viable.

​
Work That Now Gets Done (Wasn’t Worth It Before)

Comprehensive E2E test coverage:
  • Manual effort: 4-6 hours per scenario
  • AI effort: 45-60 minutes per scenario
  • Result: 21 E2E scenarios (wouldn’t exist manually)
35-page organization model:
  • Manual effort: Would never write it
  • AI effort: 8 hours (Evaluator design + Builder implementation)
  • Result: Consistent agent behavior, clear decision rights
127 API routes tagged with visibility:
  • Manual effort: Mind-numbing, error-prone
  • AI effort: 3 hours (systematic, consistent)
  • Result: Generated customer, platform, and partner SDKs
Complete ADR documentation:
  • Manual effort: Written inconsistently, skipped when busy
  • AI effort: Template-based, generated during planning
  • Result: Full decision history, future-proofed architecture
The pattern: Work with poor effort-to-value ratio (high manual cost, moderate value) became economically viable. This is where the real 10x lives: doing valuable work that would never get done manually.

​
The Connection: Mental Compilation + AI

In The Lost Art of Mental Compilation, I argued that fast builds create lazy developers who rely on the compiler to think for them. The parallel with AI is striking:

​
The Lazy Pattern (Reflexive AI Usage)

1. Write vague prompt
2. AI generates code
3. Looks reasonable → ship it
4. Bugs in production
5. Repeat
Result: Pattern-matching without understanding. Fast, but fragile.

​
The Disciplined Pattern (Deliberate AI Usage)

1. Think deeply about requirements
2. Write clear, specific prompt
3. AI generates code
4. Verify against mental model
5. Understand why it works
Result: AI validates your reasoning, doesn’t replace it. The meta-insight: Just as fast compilers enable lazy thinking, instant code generation enables lazy design. The discipline is the same: Think first. Validate second. AI should verify your reasoning, not do your reasoning for you.

​
Data Summary: The Real Speedup Multipliers

Based on 7 weeks and 524 commits:
Work TypeSpeedupWhen It Applies
Systematic implementation8-10xWell-defined patterns, clear requirements
Feature development2-4xNormal features with good design
Breaking changes0.1x (slower!)System-wide refactoring, cascading errors
Novel problems1x (no speedup)Requires creative architectural decisions
Documentation∞ (infinite)Work that wouldn’t happen manually
Verification2-3xComprehensive testing, edge case discovery
Overall average across all work types: ~3x speedup (not 10x) But:
  • Quality improved (bugs caught pre-merge)
  • Architecture improved (forced clarity)
  • Documentation improved (economically viable)
The real question: Would you rather ship 10x more code, or ship 3x more code with 10x better design quality?

​
Implications: What This Means for Developers

​
1. Your Typing Speed Is No Longer Relevant

Before AI: Fast typists had an advantage With AI: Design clarity is the differentiator The shift: From “how fast can you write code?” to “how clearly can you think about systems?“

​
2. Verification Becomes a Core Skill

Before AI: Code review was a gate before merge With AI: Verification is ongoing (did AI understand correctly? Did it hallucinate?) The new skill: Spotting the difference between “code that compiles” and “code that solves the problem.”

​
3. Documentation Debt Is No Longer Excusable

Before AI: “We’ll document it later” (never happens) With AI: Documentation is nearly free The new standard: Every architectural decision documented (ADR), every feature has examples, every workflow has a guide. If you’re not documenting with AI assistance, you’re choosing technical debt.

​
4. Bad Developers Will Ship Faster (For a While)

The uncomfortable truth: AI accelerates pattern-matching. If your workflow is “copy-paste until it works,” you’ll ship more code, faster. But shipping code ≠ solving problems. Eventually, the technical debt compounds faster than AI can patch it. The reckoning: Teams that optimize for “lines of code per day” will drown in their own velocity.

​
5. Good Developers Will Design Better Systems

The opportunity: If you were already thinking deeply about architecture, AI removes implementation friction. You can now:
  • Try multiple design approaches (implementation is cheap)
  • Build comprehensive tests (economically viable)
  • Document decisions thoroughly (nearly free)
  • Focus on the hard problems (system design, not syntax)
The advantage compounds: Better design → clearer context for AI → better implementation → better system.

​
Conclusion: Different, Not Faster

After 7 weeks and 8,000+ lines of code, the data is clear: AI didn’t 10x my speed. It fundamentally changed what I spend time on. Before AI:
  • 80% typing code
  • 15% designing systems
  • 5% reviewing
With AI:
  • 30% designing systems
  • 30% crafting context for AI
  • 40% verifying AI output
Net time saved: ~20-30% (not 90%) But the quality changed:
  • Better architecture (forced by prompting discipline)
  • Better documentation (economically viable)
  • Better tests (comprehensive coverage)
  • Fewer bugs (caught in verification)
The controversial conclusion: If you measured me by “lines of code per hour,” AI made me 8-10x faster. If you measured me by “time to ship a feature,” AI made me 2-4x faster. If you measured me by “quality of design decisions,” AI made me SLOWER (more deliberate). And that’s exactly what matters.

​
The Challenge: Measure Yourself

Track your next project with AI. Don’t measure:
  • Lines of code written
  • Time saved typing
  • Features shipped
Measure:
  • Time spent on design (before any code)
  • Verification time (checking AI output)
  • Bugs caught pre-merge (vs. in production)
  • Documentation created (that wouldn’t exist manually)
Then ask: Are you 10x faster, or fundamentally different? My prediction: You’ll find the same pattern. AI doesn’t make you 10x faster at the same work. It makes different work economically viable. And forces you to think more clearly about the work that matters. That’s not 10x productivity. That’s a paradigm shift. And paradigm shifts don’t fit on a marketing slide.

​
Discussion

What’s your experience with AI productivity claims? Are you actually 10x faster, or are you doing different work? Share your data: