Telexpress: Keeping an AI-written codebase under control

At a glance

The code was moving.
Control over it wasn’t.

Telexpress’s 15 engineers ran roughly 13,000 AI coding sessions in a single month. Output had never been higher. Confidence in what was shipping had never been lower.

The team described a codebase that felt like it was spiraling:

Production outages. Changes reached production without the configuration, scripts, or flags they depended on.

Bugs resurfacing. Problems the team had already fixed once came back in new sessions, because the agent had no memory of the fix.

Mistakes propagating. An agent would copy a flawed pattern from elsewhere in the codebase, and the next session would copy it again.

Context piling up. files kept growing as engineers made system design choices, yet agents still ignored them.

The underlying issue was familiar. The standards existed. They were written down. Agents didn’t consistently follow them, and nobody could say how often, or where.

Engineers were spending their time catching repeated code, correcting work that missed team standards, and repairing output after the fact.

From a feeling to a number

XTrace started by measuring the problem. The team reviewed a baseline sample of Telexpress’s past AI coding sessions alongside its hot-fix history.

The headline finding: agents missed a written instruction in roughly 30% of sessions.

The diagnosis gave Telexpress something it hadn’t had before: a list of specific, recurring failure patterns, ranked by how often they occurred and how much they cost.

Writing down a rule didn’t make the agent follow it. The standards needed to become part of the agent’s workflow.

24 rules, each one traced
to something that went wrong

Telexpress turned the diagnosis into 24 company rules in XTrace Rulebooks. None were generic best practices. Each came from the team’s own history.

Rulebooks put each requirement into the agent’s workflow, so it applied in every session for every engineer. A shared Brain held what the agents learned and logged, so knowledge from one session was available to the next.

Over the month, the 24 rules triggered 4,800 times across the team’s sessions.

One rule in depth:
the release handoff

One of the 24 rules shows how the approach works in practice. It came directly from the production outages.

The problem. Shipping a change required more than merging code. A release could also need a database backfill script, a new environment variable, or a feature flag applied in production. Each engineer tracked those requirements independently. Before every weekly release, the whole team met to tell the DevOps owner what needed to happen alongside the deployment.

That meeting was how scattered knowledge became a release plan. It was also where information got lost. An agent could introduce an environment variable without the engineer realizing it. An engineer who didn’t know it existed couldn’t report it. The change reached production without the configuration it needed.

The rule. Telexpress created a company rule requiring AI agents to log database scripts and necessary variables in a shared Brain as they worked. An automated XTrace agent then summarized those records in a comment on the release pull request.

The outcome. Telexpress completed five deployments with this workflow during the month and eliminated the pre-deploy meeting for each one. No deployment in the period shipped with a missed release requirement. A requirement introduced during development now had a defined route to the person deploying it, and its visibility no longer depended on someone remembering to mention it.

That is one rule. The other 23 worked the same way: a known failure, a requirement placed in the agent’s workflow, and a check that it held.

24 rules. Zero violations.

At the end of the month, XTrace repeated the audit. The follow-up review found no violations of any of the 24 rules in the sessions checked.

The failure patterns Telexpress had identified at the start stopped recurring. Engineers spent less time repairing agent output, and the standards the team had written down were finally the standards the agents followed.

Beyond guardrails:
visibility into the work behind the output

The rules were built to prevent mistakes. They also gave Telexpress something more: a clear view of how its AI engineering was performing.

Session volume shows how much AI is being used. Reviewing those sessions shows what the work looks like and what corrections sit behind it. With XTrace, Telexpress could see:

Standards adherence. Which rules fired, how often, and in which parts of the codebase.

Engineering efficiency. Where sessions stalled, looped, or needed human correction. Correction time fell from ~6 to ~2 hours per engineer per week.

Token spend. Shorter instruction files and fewer repair sessions cut token usage by 18% over the month.

Shared knowledge. Reviewed lessons, decisions, and proven fixes stayed in the Brain for later sessions, so one engineer’s fix reached the whole team.

For a team running thousands of AI sessions a month, that visibility turns AI usage from an activity count into something that can be managed.

What the results show

In one month, Telexpress went from a codebase it felt was getting away from it to one governed by 24 rules drawn from its own history, with no violations found in audit.

The month covered approximately 13,000 AI coding sessions across 15 engineers and five deployments. Those figures describe the engagement’s scale, not the audit sample. The zero-violation finding applies to the sessions and rules audited, and is not a guarantee that every session was violation-free.

The five eliminated meetings are one concrete, countable outcome of one rule. Total engineering hours recovered and the change in feature delivery time have not yet been quantified for this reporting window.

Bring your engineering standards into the agent workflow. Request an XTrace demo.