AI can't fix stupid

"Just let AI write all the code. It'll be faster."

I hear this a lot. And honestly? It makes me nervous.

Not because AI can't write code—it absolutely can. But because the companies saying this are the same ones that will be debugging AI-generated spaghetti six months from now, wondering why their "accelerated" project is now a maintenance nightmare.

Here's what we've learned after implementing AI across our entire software delivery lifecycle: AI doesn't make bad processes faster. It makes them faster at producing bad outcomes.

And that's exactly why we're doubling down on human expertise while we triple down on AI acceleration.

The big hairy audacious goal

At Vervint, we've committed to something that sounds impossible: By the end of 2026, we will reduce software delivery time and cost by one-third compared to today—while simultaneously improving quality and budget certainty.

One-third faster. One-third cheaper. Higher quality. More predictable.

Most organizations would pick two of those four. We're going for all of them. The secret? It's not in the AI tools. It's in understanding where humans excel, where AI excels, and—most critically—how to create quality gates that ensure each step's output is exactly what the next step needs.

Where humans excel: Setting the rules of the game

Let's be clear about something: AI is phenomenal at execution within defined boundaries. But it's terrible at defining those boundaries in the first place. That's where humans shine.

Humans excel at:

• Strategic Architecture – We make the foundational decisions that determine whether a system is maintainable five years from now or becomes technical debt in five months. AI can generate code patterns, but humans choose which patterns matter for your specific context.
• Quality Standards and Guardrails – Before any AI generates a single line of code, humans define what "good" looks like. We don't invent these standards ourselves, we reference proven frameworks like OWASP for security, SOLID principles for code quality, and established style guides for consistency. Then we codify them into scaffolding and reference architectures.
• Business Logic and User Experience – AI can translate a design into code, but humans determine what the user actually needs and how the business logic should flow. The judgment calls that make software genuinely useful? That's all human.‍
• Quality Gates at Every Stage – This is the critical one. Humans validate that each stage's output meets the standards required for the next stage. Product leaders validate requirements before they become designs. Technical leads review and approve code before it moves to testing. Each gate ensures quality flows through the pipeline.

Where AI excels: Executing within the rules

Once humans set the foundation and the rules, AI becomes a force multiplier.

AI excels at:

• High-Speed Execution of Defined Patterns – Give AI a proven reference architecture and clear coding standards, and it will generate compliant code faster than any human team. We've seen 3x velocity improvements when AI is properly constrained.
• Consistent Application of Standards – AI never gets tired, never shortcuts the style guide, never forgets the security checklist. It enforces the rules humans define with perfect consistency.
• Translation Between Formats – Converting Figma designs into working React components? Transforming requirements into test cases?  When the input is well-structured  AI handles these translations rapidly and reliably.
• Boilerplate and Repetitive Code – The boring stuff that drains developer energy? AI crushes it. This frees human developers to focus on the interesting problems that require judgment and creativity.

The Partnership Model: Quality compounds through the pipeline

Here's the insight that changed everything for us: In software delivery, each stage consumes the output of the previous stage. If Stage 1 produces garbage, Stage 2's AI will efficiently build garbage at scale.

Think about it like a relay race. If the first runner hands off the baton poorly, the second runner—no matter how fast—starts at a disadvantage. In software, AI accelerates the handoff, but humans ensure what's being handed off is worth accelerating.

Our partnership model works like this:

Foundation Phase: Humans Define, AI Enforces

Humans create the scaffolding—proven design patterns, reference architectures, security standards, coding conventions. These aren't invented from scratch; they're curated from industry best practices like OWASP, SOLID principles, and established style guides.

AI then enforces these standards consistently across every project. What used to take weeks of setup and review now happens in hours, with higher consistency than human-only teams ever achieved.

Design Phase: Humans Envision, AI Translates

Humans create the vision—wireframes, user flows, business logic. This is where strategic thinking happens, where we determine what the software should actually do.

AI translates these designs into working code, generating skeleton components directly from Figma frames. But humans remain the quality gate, reviewing whether the translation captured the intent correctly before that code becomes the foundation for the next phase.

Build Phase: Humans Architect, AI Generates

Humans make the critical architectural decisions—how components interact, where to place boundaries, what patterns to use. These decisions determine long-term maintainability.

AI generates the implementation within those architectural boundaries, filling in boilerplate, applying patterns, and automating repetitive code. We treat AI like a junior developer: give clear instructions, provide good examples, review the output, and send it back if it doesn't meet standards.

Validation Phase: Humans Verify, AI Executes

Humans define what "working" means—test strategies, acceptance criteria, edge cases to consider. AI then generates and executes tests at a scale and speed that manual testing can't match. But humans remain responsible for determining whether the test results actually mean the software is ready.

The lesson we learned the hard way

Early in our AI adoption, we made a critical mistake. We set up elaborate agent rules in our IDE; 160 carefully crafted instructions for writing modular, reusable, testable code. We felt prepared.

Then we added a new AI plugin and assumed it would follow our rules automatically. It didn't. We got code with no unit tests, no integration tests, imports in the wrong order. The AI had happily generated non-compliant code because we hadn't explicitly told it to follow our rules.

The lesson? AI can't fix stupid. If you ask it to do something poorly, or if you create conflicting rules, it will efficiently produce poor results.

We also discovered something else: when we DID provide solid reference architecture and clear rules, the AI was remarkable—not just following the rules, but suggesting ways to enforce them better and adding libraries and build steps we hadn't defined ourselves.

The quality of AI's output is entirely dependent on the quality of the guidance humans provide. And that's why human quality gates at every stage are non-negotiable.

Making this real: The Practical Framework

If you're implementing AI in your software delivery, here's what we've learned works:

Start with Foundation, Not Features – Before AI generates a single line of code, invest in creating reference architectures, coding standards, and security guidelines. These become the constraints that make AI useful instead of chaotic.

Create Quality Gates Between Every Stage – Product leaders validate requirements. Design leads approve wireframes. Technical leads review architecture decisions. Test leads verify test strategies. Each gate ensures the next stage has quality input to work with.

Treat AI Like a Junior Developer – Validate up front that it's following your established rules. Don't skip the code review process. Don't assume it understood your intent. Verify, then trust.

Measure What Matters – Track velocity, yes. But also track quality metrics: defect rates, technical debt, maintainability scores. Speed means nothing if you're building unmaintainable systems.

Keep Humans in the Loop for Judgment Calls – Any decision that requires context, strategy, or long-term thinking? That's a human decision. Let AI handle the execution.

Why this matters now

The organizations that will win with AI in software delivery aren't the ones with the most AI tools. They're the ones who understand that AI amplifies whatever process you feed it.

Good process + AI = exponentially better outcomes. Bad process + AI = exponentially faster disasters.

Our one-third reduction in time and cost isn't about replacing human judgment with AI execution. It's about freeing humans from repetitive execution so they can focus on the judgment calls that AI can't make—and then letting AI execute those decisions at scale with perfect consistency.

The companies that figure this out will ship better software, faster, with happier teams. The ones that don't will be debugging AI-generated technical debt while their competitors are already shipping version 2.0.

The question that matters

As you think about AI in your own software delivery, here's what I'm curious about:

Where in your development process do you most need human judgment, and where would consistent execution at scale make the biggest difference?

Because that answer—specific to your context—is where the Human-AI partnership will create the most value for your team.