A good engineer can now produce in an afternoon what used to take a sprint. That change is real, and it came faster than most teams planned for.
Imagine a kitchen that just hired a dozen line cooks who never sleep, never argue, and do exactly what the recipe card says. You'll get plenty of food, but if the recipe card is vague, you get a dozen confident, identical mistakes.
What has always been expensive in software is getting it wrong: deciding what should exist, and fitting it into an architecture that has already made its choices. Then there's the edge case that only shows up under load, the customer data you have to protect, and the moment someone asks whether this is safe to release and you need a better answer than optimism.
At Charm, we’ve rebuilt our engineering process around AI agents, from design and development to testing and production. The question is how to turn that speed into software we can trust, and make every lesson available to the next agent that takes on the work.
What AI-first means here
AI agents are part of our default development workflow. We plan how they will contribute before work begins: exploring options, implementing changes, checking results, and investigating what happens in production. Four rules guide that work:
- Humans own intent and judgment.
- Agents do the exploring and the executing.
- The engineering system checks the result.
- Every correction goes back into the system.
Agents move fast. Architecture decisions, accepting risk, and accountability for production stay with engineers.

For most of our work, what limits us is the system around the model. Some problems exceed what the model can reliably handle. Others depend on context that only lives in someone's head, which means we have more work to do before an agent can help. Most of our day-to-day engineering gives us room to improve the context and checks around the model.
We build agents for fraud, scams, and cybercrime operations, where reliability and human accountability are part of what we have to deliver. When our copilot suggests a next step to an analyst on a live call with a scam victim, a wrong suggestion affects someone who has just lost money. Holding our own engineering to a lower bar than we ask our customers to accept would be reckless.
Design: argue before the code exists
Any substantial piece of work starts with a design document. An agent helps us explore options and check them against the architecture we already have. Once we agree on a direction, the engineer and the agent turn it into a concrete implementation plan.
The agent explores and drafts. The engineer pushes back, simplifies, and, most importantly, owns the result.
A senior engineer reviews the plan before implementation begins. We still review the resulting pull request, but the architectural decisions have already been challenged. Reviewing architecture in a forty-file diff is expensive because the work is already done. Nobody wants to throw it away, so architectural objections quietly lose. Reviewing the plan moves that argument to a point where changing direction costs minutes.
We keep plans in the repository, so they become a record of why things are the way they are and which decisions got us there. Recently, a plan written months earlier explained why part of our speech-to-text pipeline was built the way it was. Nobody had to piece it together from memory.

Isn't this slower?
At the start, yes. A plan review costs minutes to hours before any code exists. We keep that cost small: plans are short and reviewed asynchronously, small fixes skip the design doc, and while one plan waits for review, the engineer's agents work on others in separate worktrees or remotely. In return, we skip the rework that comes when an architectural objection shows up inside a forty-file diff.
Giving an agent room to execute before agreeing on the objective can get expensive. We once asked an agent to compare a few cost optimizations. It explored the code, built a test harness, and started paid model runs before anyone had agreed on what to measure. Nothing broke, but the money went to a question nobody had approved. A human on the loop finds out what happened. A human in the loop decides what happens.
Development: teaching the codebase to teach
Any agent can write code. What we needed was an agent that writes our code, with our security standards, abstractions, conventions and production expectations already built in.
Human engineers pick these up through code review and hallway conversations. Agents need them written down. So we took knowledge that lived in people's heads and turned it into rules and skills the agent loads when it needs them: how the repository is laid out, how we test, the deployment pitfalls everyone has learned to work around.
The one-correction rule
Whenever a human corrects an agent, we turn the correction into a lasting rule and put it as close to the relevant code as we can. A review comment fixes one pull request, but a rule fixes every similar pull request after it.
The rules are short and specific. Changes to shared code run the full test suite. Sensitive data never goes into logs. Production diagnostics use a log level that is actually emitted, but a written rule only works if something makes sure it's followed. The standards that matter most get a check that doesn't depend on the instruction file.
We learned how much that matters by checking our own work. The first version of our bug digest turned each bug into a written lesson and a skill for the agent. Before shipping it, we replayed six months of history, 2,039 pull requests, against the roughly 170 rules we had already written from corrections. Every bug class that came back had returned through a sibling code path the original fix never touched. The written rules weren't stopping them.
So the rules that matter now end as guards. Each recurring bug class is one sentence plus a detector that runs against the current code. Every pull request is checked against that list, and every two weeks a digest reports what the detectors and production telemetry found, capped at five verified items.

The weak spot is that this process only adds. A rule that made sense when we wrote it can turn into pure friction a few months later, and nothing flags that on its own. So every so often we point an agent at the rule set and ask which rules no longer match the code. Agents already treat any rule that names a file or function as a claim to verify, and propose a fix when it's out of date. Next, we're making retirement automatic for the guarded classes: a detector that stays silent for a quarter retires its class.
What the agent can see
A lot of this is what people call context engineering. What an agent produces depends less on how you word the request than on the code and documents in the repository it can learn from. Keeping a design document or implementation plan in the repository gives future agents access to decisions made outside their conversation.
So after a bad result, we ask what the agent would have needed to get it right, and where that information should live so it's there next time.
Sometimes the answer is a rule. More often it's a file nobody pointed the agent to, and more context is often worse: an agent pointed at a whole repository does worse than one pointed at the four files that matter. Choosing what to leave out turns out to be the hard part, and it's the skill that carries over least from working with people.
One engineer, multiple agents
Once a plan is approved, each agent works in its own Git worktree, spins up its own copy of our system locally, and comes back with proof the task works: a test that failed before and passes now, a screenshot of the changed screen, or a before-and-after run on real data.
We still review the code itself, with that evidence available alongside the changes. That is what lets one engineer have a feature being built, a bug being investigated and a change waiting for review at the same time.
The tooling can handle more, but our attention is what runs out: past a certain number of parallel tasks you stop reviewing and start rubber-stamping, and knowing where that line is matters more than pushing it.
Testing and review: where the rules came from
For bug fixes, we first reproduce the problem with a failing test, then fix it. Automated checks build every changed service and handle linting, types and tests. An AI reviewer checks the pull request against our written rules, the code's history and past review comments. Human reviewers focus on the approach, simplicity and risk.
Many of these rules came from failures. Early on, an agent checked a change to shared code against a filtered subset of tests. They passed, and a sibling component broke. That's where the rule to run the full suite on shared changes came from, and it hasn't happened again.

Production: agents after the merge
We keep using agents after deployment. Scheduled jobs audit feature flags and watch production telemetry for health signals that look wrong. Agents also read product usage: how a feature is used, whether people adopt it, and whether a release did what we expected.
During incidents, agents search logs and compare metrics to narrow down the cause. In one latency investigation, the first guess was a missing database index. Comparing client-side and server-side timings showed the database was mostly idle; the real delay was in the application's connection pool. We wrote down the method afterward, so the next incident starts from what we already learned.
Agents get more access as they earn it: supervised coding first, then reviewed execution, then production investigation.
Does it work?
Last quarter our R&D team merged about 1,200 pull requests and reverted 10 of them. Since we moved to this process at the start of the year, merged changes per engineer have roughly doubled and the typical change has grown about four times larger, while the share we later reverted has stayed around one percent. We’re shipping more, without seeing a rise in the share of changes we have to roll back.
One engineer recently shipped a feature that runs from the browser client, through our audio pipeline, into the backend, in about two days: five implementation plans, carried out by agents, checked by automated tests, reviewed by humans, and released. It has been running in production since, with no bugs reported against it.
Two days is nice. What stayed with us more is that a change touching three services felt routine.
Keeping what we learn
As engineers, we produce software and gain judgment while building it. The software ships, but the judgment usually disappears into people's heads, closed pull requests and Slack threads nobody will search again. That judgment is what we're trying to keep.
In short:
- Humans own intent and judgment, agents explore and execute, and the engineering system checks the result.
- Review the plan before implementation, while changing direction is still cheap.
- Every correction becomes a rule, and the rules that matter become guards that run on every change.
- Context beats prompting, and a little of the right context beats a lot of it.
The cooks got faster. What keeps the food safe is still the head chef, the recipe cards, and tasting everything before it leaves the kitchen.
All of this is about confidence. Agents made code cheap, and the process is what gives us confidence that the result is safe to ship. We build agents that work beside fraud analysts under one standard: the human stays accountable, the agent does the legwork, and the system checks the work. As an AI-first company, we apply that same standard to the agents that build Charm, too.





