DEV Community

Job from Kilo
Job from Kilo

Posted on Originally published at blog.kilo.ai

A Core Merge Is Not a Feature

The work isn’t done when the PR merges. It’s done when someone can use it.

A word from our VP of Engineering Emilie Schario

Nobody uses Kilo Core directly. They use VS Code, JetBrains, the CLI, Agent Manager, or Desktop. Core is the shared code that powers all of those experiences.

This distinction matters because merging code is not the same thing as shipping value to a customer.

At Kilo, we've always optimized for getting value into users' hands as quickly as possible. We don't organize our work around monthly releases, big launches, or waiting until every client has the same functionality.

We organize around one question: What's the smallest thing we can ship that delivers value to a user?

And then we ship it.

Shipping Shouldn't Require Permission

Kilo clients release multiple times a week. Any engineer can cut a release. There's no release manager to wait for, no train to catch, and no reason to hold finished work until an arbitrary date on the calendar.

This is important because the economics of small changes are completely different when you can ship them immediately.

If you only release once a month, there's not much incentive to ship a small improvement independently. It's going to sit alongside dozens of other changes anyway.

But when you can release multiple times a week, every small improvement is an opportunity to get something useful in front of a customer, learn from it, and keep moving.

We would release every day if that were the best experience for users.

In fact, we learned that it wasn't. VS Code users told us that daily upgrade notifications were annoying, so we adjusted to releasing a few times a week.

The point isn't to release as frequently as humanly possible. It's to release as frequently as is useful to our customers.

Ship to One Client First

When you're building on shared core infrastructure, there's a temptation to define a feature as complete only once it's available everywhere.

That sounds reasonable. It also creates unnecessary dependencies and slows down the time it takes to get feedback from real users.

Instead, we aim to build the behavior in Core and release it through one client first.

This gives us two things:

  1. We get real user feedback without waiting for every client to implement its UI.

  2. The next client can build on functionality that's already been exercised by real users, rather than duplicating the work.

Kilo Swarm is a good example.

In September 2026, we shipped Swarm, which allows agents to coordinate their work through a shared board. But we didn't ship it all at once.

  • September 2: Swarm cards and naming landed in VS Code.

  • September 3: Agent identity and execution state were exposed through shared Core code.

  • September 14: The shared board became enabled by default, after initially being opt-in.

  • September 15: Swarm became a top-level configuration setting.

  • September 17: JetBrains merged support for the board.

By the time Swarm was enabled by default, users had already been using it for nearly two weeks.

We'd already found and fixed issues, including a particularly fun one where agents could message themselves.

We didn't need to wait for the entire experience to be complete before we could learn from it. And we didn't need JetBrains to be ready before VS Code users could benefit.

The Hard Part Is Consistency Across Clients

There's a tradeoff here that we have to be intentional about.

Shipping to one client first is a great way to move quickly. But if we aren't disciplined about following through, we end up with a fragmented product where functionality depends on which client someone happens to use.

We've seen both sides of this.

Enhance Prompt is an example of where we could have done better.

Enhance Prompt rewrites a user's prompt before they send it. We first shipped it in VS Code in March 2026.

JetBrains got it in June. Agent Manager got it in July. And Desktop doesn't have it yet.

The underlying functionality was already in Core. What was missing was the client-specific UI to expose it.

So why did it take four months to get from the first client to the third?

Not because the implementation was particularly complicated. Because we didn't treat the other clients as explicit follow-up work that needed to get done.

Compare that with Kilo Swarm.

Swarm's identity, board, and configuration were built into Core from the beginning. JetBrains support landed just 15 days after the initial VS Code experience.

The difference wasn't that one feature was easy and the other was hard.

The difference was that with Swarm, we knew which clients needed to come next. With Enhance Prompt, we added support when someone noticed it was missing.

That's a process problem, not a technical one.

And the solution isn't to slow down the first release until every client is ready.

It's to make sure we know what needs to happen next, who owns it, and that the work doesn't disappear after the initial release.

Sometimes You Have to Go Slow to Go Fast. Usually, You Just Have to Go Fast.

There's a saying in engineering that sometimes you have to go slow to go fast.

And sometimes that's true.

Building shared infrastructure in Core, rather than implementing functionality independently in each client, can require more work upfront. But it pays off when the second, third, and fourth clients can reuse that functionality.

Swarm is a great example of making that investment early.

But I think engineers overapply this principle.

Too often, "going slow to go fast" becomes an excuse to keep designing, keep planning, or keep polishing instead of putting something in front of users.

Most decisions are reversible. Especially when you can ship a correction a few days later.

I'd much rather have a team make a decision today, ship something useful, and learn that they need to adjust it next week than spend a month trying to make the perfect decision without any real feedback.

The fastest way to learn whether something works is to let someone use it.

This is why our release cadence matters so much. It makes the cost of being wrong relatively low, and the value of learning quickly incredibly high.

But none of that works if we confuse making a change with delivering value.

A Merge Is Not the Finish Line

I think one of the easiest traps for engineering teams to fall into is measuring progress by what they've completed internally.

The PR is merged. The demo looks good. The ticket is closed.

But none of those things mean a customer has received any value.

This is especially important when we're working in Core, because the distance between merging code and putting it in front of a user is easy to overlook.

So here's what I expect from engineers working on shared functionality:

  • Build shared behavior in Core. If multiple clients will need the functionality, don't implement it independently in each one.

  • Pick the first client and ship it. Don't wait for parity across all clients before getting value to users.

  • Make follow-up work explicit. Know which other clients need support and who is responsible for delivering it.

  • Own the release. Any engineer can cut a release. If your work is ready, don't wait for someone else to schedule it.

  • Measure completion by customer value. The work isn't done just because the code is merged. It's done when someone can actually use it.

Ultimately, I don't care how many PRs we merge or how many features we demo internally.

I care how quickly we can turn engineering work into something useful for our customers.

That's the finish line.

Top comments (0)