How AI Coding Tools Changed Our Engineering Velocity (Without Changing Our Standards)
Direct answer: AI coding tools like Cursor and Claude increased our engineering velocity by compressing boilerplate, exploration, and first-draft implementation — without lowering standards, because we kept human review, tests, domain documentation, and a hard rule against secrets in prompts.
At MarginTop Solutions, AI is an accelerator for disciplined teams, not a substitute for judgment. The honest version of this story includes both the gains and the guardrails that made them sustainable.
What the research actually says
Before talking about our experience, it's worth grounding this in published data. The claims about AI coding productivity range from wildly optimistic to soberly skeptical, and both extremes miss the nuance.
- A Microsoft/GitHub Research study (2022) found that developers using GitHub Copilot completed tasks 55.8% faster on average — but the task was a well-defined HTTP server exercise with a clear spec. Real product tasks are messier.
- A McKinsey study (2023) found software developers using generative AI tools completed certain coding tasks 35–45% faster in controlled conditions, with the largest gains on documentation, code explanation, and refactoring.
- A METR study (2025) testing AI agents on real-world open-source tasks found that AI-assisted developers were actually slower on complex long-horizon tasks — suggesting AI helps most on contained, well-specified problems, not ambiguous multi-day engineering work.
Our experience matches the nuance: the gains are real, but concentrated in specific task types. AI is not uniformly faster — it's selectively faster on the right problems.
What actually got faster for us
| Task type | AI impact | Our experience |
|---|---|---|
| Scaffolding CRUD, migrations, tests | High | 2–4 hours of boilerplate becomes 20–30 minutes of review |
| Explaining unfamiliar codepaths | High | Onboarding new engineers into existing modules significantly faster |
| Drafting refactors with clear module boundaries | Medium-High | Good first draft, needs domain correction; still saves 40–60% of effort |
| Writing tests for known behavior | Medium-High | Coverage gaps still need human judgment; AI good at the skeleton |
| Comparing implementation options | Medium | Useful for surfacing tradeoffs before committing; not a replacement for architecture review |
| Ambiguous multi-day feature work | Low-Medium | AI output needs heavy domain correction; gains shrink as complexity grows |
| Business logic with implicit rules | Low | AI doesn't know your invoicing edge cases. Write them down first — then AI helps implement them. |
The guardrails that protect standards
Speed without guardrails is just bugs shipped faster. Here's what we don't compromise on:
- Review is non-negotiable. AI output is a pull request, never production. We review AI-generated code more critically than hand-written code, because it tends to be confidently wrong in subtle ways.
- Tests still gate merges. Especially around money, authentication, and tenancy boundaries. A test suite that AI generated needs to be read like code you're reviewing — not trusted because it passes green.
- Domain docs beat vibes. AI tools perform dramatically better when invariants are written down. A well-maintained
DOMAIN.mdthat explains your permission model, pricing rules, and multi-tenancy approach is worth more than a 100K-token context window. - No secrets in prompts. Ever. API keys, customer data, production dumps, PII — none of it goes into model context. This is a hard rule, not a guideline. See security basics for why.
What didn't change
The things AI didn't fix, and never will:
- Unclear requirements. A well-prompted AI produces confident code for unclear specs. The output is usually wrong in ways that take longer to debug than building it correctly from a clear spec.
- Architectural judgment. Whether to extract a service, how to model a multi-tenant billing system, when a domain boundary is real versus premature — these remain human decisions. AI can surface options; it can't make the call.
- Client trust. Our clients hire us because they trust our judgment. Shipping AI-generated code without review and calling it "AI-accelerated delivery" is a different business from what we run.
Our honest net assessment
We're faster on contained, well-specified work. We're about the same speed on genuinely ambiguous architectural problems. We're occasionally slower when we have to debug AI-generated code that was subtly wrong about our domain.
The net is positive — meaningfully so on the types of client work we do. But it's not the 10× productivity claim you see in AI product marketing. It's a real, compound acceleration on the right tasks, with a real operational overhead of maintaining quality guardrails that make it sustainable.
Security sequencing still matters: basics before fundraising. Hiring still filters for ownership: hiring as a first-time CTO.
Key takeaways
- Published research (GitHub/Microsoft, McKinsey) shows 35–55% speed gains on well-defined tasks. Real product work gains are smaller and more varied.
- AI accelerates boilerplate, scaffolding, exploration, and refactoring. It doesn't replace domain knowledge, architectural judgment, or code review.
- The guardrails matter as much as the tools: human review, test gating, domain documentation, and no secrets in prompts.
- Write down your business rules before prompting AI to implement them. That investment pays off regardless of which AI tools you use.
Thinking about how to adopt AI tools without compromising engineering standards? Get in touch — this is something we think about every week.