The promise of AI coding is exponential speed. But for many engineers, the reality is downgraded models, confusing pricing, rate limits, and model lock-in. This is all artificial friction (we’re calling it AI drag) introduced by the very tools that are supposed to be making developers more productive.

At the other end of the spectrum, Kilo Speed is what’s possible without that drag. We use Kilo to build Kilo, operating by the principles laid out in our Manifesto.

But what does Kilo Speed actually look like in practice? Software engineer John Fawcett shares a firsthand look at how he manages an “Agent Team” to ship features in days, not months.

John joined Kilo three months ago after nearly a decade at Cloudflare. Wanting to ship something on his first day, he ended up merging three pull requests, and immediately began tackling paper cuts in the Kilo dashboard to familiarize himself with the codebase. Within the first two weeks, he had redesigned the organization usage page and shipped a new shared modes feature.

This contrasts starkly with his previous environment. At a large, established company like Cloudflare, the development process was necessarily structured by a quarterly march towards progress, requiring extensive roadmaps, Product Requirements Documents (PRDs), technical specs, and Jira tickets.

Of course, at Cloudflare’s scale, three major constraints contribute to this cadence:

Scale: Cloudflare handles billions of requests daily, requiring consideration for traffic volume and edge cases. 1.

Security: As a security company, deep thought and consultation with internal security teams are mandatory. 1.

Maintainability: Software projects are expected to last for years, demanding consideration for future colleagues.

Kilo operates on a weekly cadence. John explains that Kilo’s engineers, who are also the company’s biggest customers, benefit from a high-trust environment where the “why” of any given feature is inherently understood. By avoiding unnecessary coordination and by leaning into agentic engineering, Kilo makes the entire lifecycle from idea to production go really, really fast.

To show Kilo Speed in action, John shared what went into shipping a complex, data-heavy feature: the AI Adoption Score dashboard. Built for engineering managers and executives, this feature aggregates data into high-level metrics (Frequency, Depth, Coverage) to track AI adoption and offer strategies for improvement.

Without an agentic engineering platform, John estimates a project of this scale—requiring front-end work, back-end data aggregation, and complex logic—would have taken two to three people about a month.

With Kilo, it took two days from planning to proof of concept (POC). Here is how he used an agent team model to parallelize the work:

John emphasizes that the most crucial step when working at Kilo Speed is pre-planning. You must understand the solution internally before prompting the agent, otherwise, you risk generating unmaintainable code and introducing unmanageable tech debt.

The discovery document: John first creates a discovery document—a “dumping ground” to collect random ideas, research competitor solutions, and define metrics based on the vague initial PRD. 1.

AI for context, not code: He uses Kilo’s chat window to critique the initial PRD, asking the agent to identify holes and for questions to pose to the PM. He then uses it to generate a technical specification. This is purely for building context and finalizing his internal understanding before writing any code.

Once the plan is clear, John switches from a single-threaded approach to a parallelized agent team model.

Deep work (coding agent): John focuses on the hardest, most novel problems (in the case of the dashboard, the data aggregation and core logic) using a single, local Coding Agent. This is a tight, back-and-forth loop where John guides the agent’s output for high-quality, maintainable code. 1.

Background work (cloud agents): Simultaneously, he kicks off multiple Cloud Agents for smaller, self-contained units of work identified in the discovery document. In this example, he launched an agent session to create a PR to the Kilo extension to start tracking organization IDs for the telemetry data he would need. 1.

Final review (review agent): The finished POC is opened as a pull request and reviewed by the Kilo Code Review Agent, which catches issues before final human approval.

The feeling of this speed, John says, is “exhilarating.”

To work at Kilo Speed, delegation is essential. Here are three tasks John happily delegates entirely to his agents:

Writing UI code: Though John enjoys UI work, AI agents are significantly faster and produce a solution that is “good enough” for rapid iteration. 1.

Writing tests: Models like Claude Sonnet 4.5 are highly effective at writing automated tests, freeing John to focus only on the overall testing strategy. 1.

Spinning up new projects and boilerplate: The tedious, initial configuration work for new projects is perfectly suited to an agent, which can handle setup and configurations faster and more accurately than a human.

Crucially, when John runs into a roadblock or lacks expertise (e.g., in a specific database query), he always consults Kilo first. But for high-stakes decisions, human collaboration is still essential. John seeks out dissenting human opinions because LLMs, he says, are the “ultimate Yes Man/confirmation bias machines”.

If you’re asking yourself, “How do you prevent speed from turning into a chaotic, unscalable mess?” John suggests this is the wrong question. “We try not to overindex on things like architectural quality or consistency right now. We don’t even align on long-term tech vision.” Why?

Architecture: “You don’t typically know what quality architecture looks like until you’ve built a version that doesn’t scale.” Focusing on architecture too early means focusing on the wrong things (instead of getting customers).

Consistency: Stylistic consistency is only important if it can be automated (using tools like TypeScript and Prettier).

Vision: The long-term tech vision is unnecessary until the Minimum Viable Product (MVP) fails to scale due to a large customer base.

Right now, Kilo is focused solely on building features and getting customers, leveraging the high-trust environment and seniority of its engineers.

Going from a billion dollar company to a small startup is one thing, but if you’re struggling to imagine bringing Kilo Speed to your current organization, the transition can be gradual.

John advises starting with the core of the Agent Team model he shared above:

Create a discovery document (your “dumping ground”). 1.

Formulate a clear plan (your internal solution). 1.

Identify small, self-contained units of work from that plan (the 3 Things To Delegate Entirely to Kilo above are a good place to start!). 1.

Kick off cloud agents to handle the boilerplate, tests, and UI in the background while you focus on the most difficult core logic.

An individual developer can do this, even if the organization at large isn’t ready for Kilo Speed. “Once you do the planning part, you can pretty easily see how you could parallelize your effort,” says John. “It’s a skill to be able to take an amorphous blob of product requirements and turn it into an actionable plan. In the age of AI, don’t skimp on that skill.”

Even if you’re at a large company, you can still operate like this for a POC. John points out that if you can sideline the considerations of scale, security, and maintainability for the initial prep work, you can always layer them back in after the fast-paced POC is complete.

Kilo Speed is about making developers managers of their own agent teams and accelerating work—leveraging AI to parallelize every effort. Operating at Kilo Speed is a shift that requires different cultural practices and the tech to support it. That’s how you turn what would have been a month-long, multi-person project into a two-day delivery for a single engineer.

No posts