How we built an AI-native engineering system

Every engineering leader building critical infrastructure has operated under a fundamental assumption: you can have speed or reliability, but achieving both simultaneously was considered impossible.

This isn’t a process problem or a team problem. For years, the industry accepted this as a fundamental limitation of how software gets built. Reliability requires slow, methodical release cycles. Comprehensive testing takes time. Code reviews create bottlenecks. Each layer of safety adds weeks to delivery timelines.

In EV charging platforms, the stakes are higher than in typical software. You can’t afford downtime, as every minute of unavailability means revenue loss. But you also can’t afford slow feature delivery as CPOs need to adapt as the market evolves.

We refused to accept that “slow” is the price of “safe.”

We recognized that AI had reached a level of maturity where this trade-off might finally be solvable. The question wasn’t whether to use AI—it was how to architect an engineering system in which speed and quality reinforce each other rather than compete, a shift we describe in How AMPECO Became AI-Native.

So we rebuilt AMPECO’s entire software development process around AI agents—not to choose one side of the trade-off, but to break it entirely. We automated the full development lifecycle: planning, coding, testing, and deployment, with AI handling execution while engineers direct architecture and validate quality. The impact: 2-day stories compressed into hours, bug rates cut in half, and we moved from weekly sprints to shipping every day.

Here’s how we did it.

Building the CoOperator Dev Agent

We’d been experimenting with AI coding tools for nearly two years. GitHub Copilot for autocomplete. CodeRabbit code review assistant. The AI editor Windsurf. All showed promise but delivered mixed results. Each tool gave us incremental improvements, but nothing that fundamentally changed the game.

The breakthrough came with Anthropic’s Claude Code. Previous tools required constant supervision—developers had to read intermediate outputs and type “continue” to keep the process moving. Claude Code changed this dynamic: it could work on a task without interruption, and when it signaled completion, the work was genuinely finished. Crucially, it was also scriptable via an SDK, which allowed us to embed it as a reliable step in our automated workflows.

We took our existing process—one that already worked well—and broke it down into small, individual steps. This granular approach was essential to avoid overwhelming the context limitations of current AI models.

For each step, we wrote specific instructions—the kind you would give to a human developer—defining exactly how to complete the task and what “done” looks like. We saved these instructions as executable prompts.

Then, we arranged these steps into a workflow that mirrors the exact process our human engineering team follows. We discovered that there was no fundamental step that AI couldn’t do—from writing code to QA—as long as the scope was managed correctly.

The result is what we call the CoOperator Dev Agent (CODA). It serves as a workflow manager that orchestrates the execution of these instructions, effectively running the process end-to-end. An architect phase creates a detailed plan, a developer phase writes tests and implements features, and a code review phase performs an internal peer review, strictly validating the work against coding standards, architectural patterns and story requirements. When issues are identified, the workflow loops back for fixes, repeating until the work is complete.

The AI engine: Systematically removing human interruptions

We realized that in an AI-native system, the primary constraint on speed isn’t the AI’s generation time—it’s human cycle time. Waiting for a human to review a plan or approve a step creates “dead time” that destroys velocity.

Our approach isn’t about managing “loops” of human-AI interaction. It is about establishing checkpoints and then systematically removing them as we gain confidence in the agent’s autonomy.

From supervision to autonomy

Initially, our process was heavily guarded. A Product Manager approved the story, then the AI agents (Architect and QA) generated a technical plan. A human developer had to stop, review, and approve this plan before any implementation could begin. Only then would the execution agents (Developer, Code-review, and AcceptanceTest) drive the task to completion, followed by yet another human code review.

As the agents proved their capability, we identified that the “plan review” checkpoint was a bottleneck. The AI was capable of valid planning without constant hand-holding. So, we removed that human interruption.

The current workflow

Today, once the Product Owner and Engineer mark a story as “Ready for Development,” the agents take over completely. They autonomously handle the architectural planning, test planning, implementation, and self-correction. The system iterates internally—writing code, running tests, fixing errors—until it reaches a “ready for production” state.

The human developer is brought back only at the very end for a final review. At this stage, they can approve the work or provide feedback. If the agent gets stuck or needs course correction, the developer can manually update the agent’s instructions or the project context and restart the whole process in order to make sure the update solves the problem.

The path to zero-touch

The goal is to continue removing these human checkpoints. We expect that in the coming months, we will reach a level of confidence where we no longer require a human code review for every task. By eliminating these interruptions, we allow the AI to deliver at its full theoretical speed, turning days of latency into minutes of execution.

The 25,000+ test safety net

To enable this level of AI automation, you must first have the safety nets in place. But these aren’t new safety nets we invented for the AI.

Our system rests entirely on the discipline of mandatory unit and feature tests, continuous integration, and automated security governance—practices we mastered years ago to help our human teams move fast. We simply found that these same practices help our AI agents just as well as they help our human engineers.

For us, that foundation is a massive suite of over 25,000 automated tests. An agent simply cannot define a task as “complete” until it produces the tests that prove the code works. This gives the AI immediate, programmatic feedback. It doesn’t need to “guess” if the logic is correct; the test suite tells it instantly. If a test fails, the agent self-corrects and retries until the logic is green.

This density of testing—generated at a speed humans couldn’t match—is what allows us to deploy daily without chaos. It catches regressions instantly and ensures that new features don’t break existing functionality. Without this rigid framework, an AI agent would simply produce buggy code faster than humans could fix it.

While tests are the primary guardrail, we reinforce them with other automated  static code analysis tools. Just as these tools prevented humans from merging messy or insecure code, they now block the AI agents. If the AI generates code that functions correctly but violates architectural standards, these tools stop the process.

Ultimately, we didn’t build AI on top of empty promises; we built it on top of established engineering discipline.

Human checkpoints maintained

We haven’t removed humans from the process; we have elevated their role to “Managers” of their AI colleagues. There are two critical human checkpoints that frame the autonomous workflow:

1. The Alignment Sync (Pre-work) Before any code is written, the Product Owner and the Responsible Engineer meet (virtually) to iterate on the story. The goal isn’t to dictate technical implementation details, but to align on the “what” and the “why.” They refine the requirements until both parties are satisfied. Only when the engineer explicitly marks the story as “Ready for Development” does the Agent take over.

2. The Managerial Review (Post-work) Once the Agent has completed the planning, coding, and testing, it presents the work for production review. The engineer validates the result just as a good manager would check a subordinate’s work:

• They inspect the final code and functionality.
• They review the proof of work—checking the planning logs, test results, and logic paths the Agent took.
• They provide feedback via Code Review.

If the engineer spots an issue or a better approach, they leave feedback. The Agent takes this feedback to fix the immediate code, and crucially, generates a self-improvement story to update its own instructions so the same feedback isn’t needed next time.

This consolidated accountability enables speed while maintaining quality. Responsibility isn’t diffused across multiple teams; it’s concentrated with one engineer who validates the work holistically.

Killing the old process

Our CEO Orlin Radev describes it plainly: “We didn’t just add AI tools at the fringes. We destroyed and rebuilt our development process with AI at the core.”

We cancelled traditional grooming sessions where an engineering team and the product manager would discuss all stories in an iteration. Instead, we have focused alignment syncs where humans (one engineer and one product owner) define the intent, and AI handles the technical analysis. We discontinued iteration demos because shipping daily made biweekly showcases obsolete. We moved from weekly sprints to continuous daily releases.

And the results prove it was worth it: 4x faster velocity with 50% fewer bugs per story. We didn’t trade quality for speed, instead we built a system where both improve together. We achieved this by enforcing MORE quality checks, not fewer. Test coverage increased while delivery accelerated.

The strategic shift: Velocity as a competitive moat

For a CTO, the “speed vs. reliability” trade-off is often the single biggest drag on the organization. When development cycles are slow, technical debt accumulates because teams can’t afford to refactor while meeting delivery dates. When reliability is low, the “maintenance tax”—handling production incidents and bugs—cannibalizes the roadmap.

By moving to an AI-native system, we have shifted the organization from a defensive posture to an offensive one.

When bug rates drop by 50% through automated enforcement, the engineering team stops being a cost center for fixes and starts being a factory for innovation. 4x faster development cycles don’t just mean “more features”—it means the cost of experimentation has plummeted. We can now integrate complex regulatory updates or custom reporting requirements in hours, responding to market pressures that would have paralyzed a traditional team for weeks.

The self-improving engine

This system creates a compounding advantage that traditional processes can’t match. In a standard engineering org, knowledge is siloed. When a senior developer learns a lesson, it might stay in their head or, at best, end up in a wiki.

In an AI-native system, every lesson is codified. Every time an agent generates a self-improvement story based on human feedback, that knowledge is permanently embedded into the infrastructure. The baseline quality of the entire department rises with every single task.

As Orlin puts it, “If we had started by building AI features for clients first, we would have solved today’s problem. By rebuilding the core, we have solved tomorrow’s problem.”

Building inward to move outward

We didn’t build AI agents to follow a trend. We built them because our own engineering process was the bottleneck to our mission of scaling EV charging infrastructure.

Because our agents are battle-tested on our own mission-critical production code, we have a clear blueprint for extending AI capabilities upstream—into customer success, operations, and product automation. These won’t be speculative features; they will be extensions of an architecture that already powers our core.

Six months ago, we set out to prove that speed and reliability could reinforce one another. The data proves it’s possible. The gap between AI-native engineering and traditional development is only beginning to open, but it will define who leads in the next decade of software.