Sharing this one from Emilie Schario, our VP of Engineering, who wrote about why iteration is a skill most engineers were never taught.
Shipping fast doesn’t mean taking shortcuts. It means getting good at finding the smallest change that delivers real value.
Somewhere along the way, we decided that speed and quality were competing priorities in software engineering. If you want to build something quickly, you have to take shortcuts. Skip some tests, accept some technical debt, build the version that's good enough for now, and promise you'll fix it later.
I think this is fundamentally wrong.
The fastest engineering teams I've worked with aren't fast because they're willing to compromise on quality. They're fast because they're good at figuring out what needs to be built. They understand how to reduce the scope of a problem without compromising the quality of the solution, and they know how to get something valuable into customers' hands before they've built everything they originally imagined.
That requires a skill I think most engineers are missing. Iteration is a skill, and most of us have never been taught how to do it.
We're good at building things. We're less good at figuring out what to build.
Give an engineer a problem and they'll start designing a solution. They'll think through the architecture, the dependencies, the edge cases, and how all the pieces fit together. They'll come up with a plan, break it into tasks, and start building. That's what we've trained engineers to do, and those are all valuable skills.
But there's a step missing. Before we figure out how to build the complete solution, we should be asking what the smallest change is that would make the customer's experience better. Those are two very different questions. One assumes we already know what the end state should look like. The other forces us to think about what value we're trying to create.
In my experience, engineers are much better at the first than the second. We spend a lot of time teaching engineers how to decompose technical problems, but much less time teaching them how to identify smaller opportunities to create customer value. As a result, we end up with teams that are very good at executing complicated plans but struggle to recognize when a much simpler solution could deliver value immediately.
The goal of engineering is to solve a problem for a customer.
What's the one-hour version?
One of the ways I coach engineers to get better at iteration is by asking a simple question: "What's the one-hour version of this task?"
The first response is often that there isn't one. The task requires several days or weeks of work. There are technical dependencies, infrastructure to build, authentication to implement, or whatever else is necessary to make the feature work. And they're usually right about the solution they've imagined.
But they're answering the wrong question. They're thinking about how to build a smaller version of the solution they've already committed to, rather than how to create a smaller amount of customer value.
Let's say you want to integrate two applications. A proper integration might involve authentication, APIs, data synchronization, error handling, a new interface, and a bunch of testing. There's clearly no one-hour version of all that work. But what is the customer actually trying to do? Maybe they're trying to complete a workflow that starts in one application and ends in another. Could you just add a link that takes them directly to the relevant page in the other application?
That's a one-hour version of an integration. It's not the final experience you want, and it doesn't automate the entire workflow. But it's better than what exists today. The customer can accomplish something more easily than they could yesterday, and you haven't cut a single corner on quality. You've just made a different decision about scope.
There's also the practical reality that, in my experience, engineers are bad at estimating. Ask someone for the one-hour version and there's a good chance they'll give you something that actually takes half a day. That's fine. I'm not trying to get them to finish in an hour. I'm trying to get them to recognize that there's a much smaller version of the problem worth solving.
The question is a forcing function. It makes engineers reconsider which parts of their proposed solution are necessary to create value, which parts can wait, and whether there's a completely different approach they haven't considered. The more you practice that kind of thinking, the better you get at it.
Building incrementally is not the same as iterating
I think this is where a lot of engineering teams get confused. They'll take a large project, break it into small tasks, and call that iteration. Maybe they merge a PR for the database changes on Monday, an API on Tuesday, the frontend on Wednesday, and finish wiring everything together on Thursday.
That's incremental development. It's not iteration.
Nothing about the customer's experience has changed until Thursday. And until Thursday, you haven't learned anything about whether what you're building is what the customer needs. You've made progress toward a predetermined solution, but you haven't created an opportunity to validate whether that solution is the right one.
Iteration requires delivering customer value, learning from it, and using that information to decide what to build next. If you're just breaking a predetermined solution into smaller technical tasks, you're not iterating. You're executing a plan.
There's nothing wrong with building incrementally. Sometimes technical work needs to happen before you can deliver something useful. Refactoring, infrastructure improvements, and foundational architecture can all be necessary engineering work. But we shouldn't confuse that work with iteration just because we're doing it in small pieces.
When you build incrementally, you generally know where you're going and you're organizing the work into manageable steps. When you iterate, you're deliberately creating opportunities to discover whether you're going in the right direction at all. Your next step should be informed by what happened when customers used the last thing you shipped.
That's a much higher bar than simply making smaller PRs, and it's why iteration is a skill rather than just a way to organize engineering work.
The first iteration might completely change what you build
This is the part I think people underestimate most. The biggest benefit of iteration is that you might discover the feature you were planning to build isn't what they needed in the first place.
Every product decision is based on some understanding of the customer. We think we know their workflow, what's frustrating them, and what they'll find valuable. Sometimes we're right, but often our understanding is incomplete. The only way to improve that understanding is to put something in customers' hands and see what happens.
Go back to the integration example. You could spend six weeks building a complete integration between two applications. You could do everything right from an engineering perspective and end up with a polished, reliable experience, only to discover that customers don't use it the way you expected.
Maybe all they really needed was the link. Maybe the link helps, but you discover the real problem is somewhere else in the workflow. Or maybe it becomes obvious that the integration is far more valuable than you initially thought, and you should invest more heavily in it. Any of those outcomes would be useful information, and any of them might change what you decide to build next.
But if you spend six weeks building the whole thing before putting anything in front of customers, you've spent six weeks making decisions based on assumptions that you haven't tested. You've invested in a particular end state without giving yourself an opportunity to learn whether it's the right one.
The point of shipping the link is that you can begin learning in an hour instead of six weeks. And what you learn might completely reshape the final product.
Iteration isn't about getting to your original plan faster. It's about figuring out whether your original plan was right.
I think this is particularly important as teams grow. The more people involved in a project, the easier it becomes to treat an agreed-upon specification as a commitment to a particular solution. Engineers execute against the requirements, product managers track progress, and everyone measures success by whether the original plan gets delivered. But the original plan was based on assumptions, and those assumptions should be tested against real customer behavior.
A team that's good at iteration is willing to let what it learns change what it builds. That's still discipline and planning: recognizing that the purpose of the plan was always to create customer value, not to prove that the original plan was correct.
Speed and quality aren't in conflict
I hear people talk about the trade-off between speed and quality all the time, and I think they're confusing two very different things: cutting scope and cutting corners.
If you skip tests, introduce bugs, or build something you know won't hold up because you're trying to meet a deadline, you're compromising on quality. If you identify a smaller change that solves part of the customer's problem and ship that instead, you're making a scope decision. Those aren't the same thing, and we shouldn't treat them as though they are.
In fact, being good at iteration can improve the quality of what you build. Smaller changes are easier to understand, test, review, and debug. There are fewer moving parts to reason about at any given time, and when something goes wrong, it's easier to identify what changed. You can maintain high engineering standards while delivering much smaller pieces of functionality.
More importantly, you're getting feedback earlier and more often. We spend a lot of time talking about code quality, and we should. But a perfectly engineered feature that nobody needs isn't a quality product. You can build something with clean architecture, comprehensive tests, and great performance and still have built the wrong thing.
I would much rather have a team that delivers small, well-built improvements, learns from customers, and adjusts its direction than a team that spends months building a perfect implementation of an untested idea. The first team is using speed to improve the quality of their decisions, while still holding themselves to high standards for the code they ship.
That's why I don't believe speed and quality have to be competing priorities. When you're intentional about how you iterate, they can reinforce each other.
Iteration takes practice
I don't think most engineers are naturally good at iteration, and I don't think that's particularly surprising. It's not a skill we've historically prioritized teaching. We've taught people how to design systems, break projects into tasks, write maintainable code, and estimate how long something will take. But we haven't spent nearly as much time teaching them how to look at a large problem and identify the smallest change that creates value.
The good news is that you can get better at it. Like any other engineering skill, iteration improves with deliberate practice. The more often you challenge yourself to find a smaller, independently valuable version of a task, the more naturally you'll start to see those opportunities.
The next time you're looking at a task that's going to take two weeks, ask yourself what the one-hour version would be. If your immediate reaction is that there isn't one, that's probably a sign that you're too attached to the solution you already have in mind. Go back to the customer problem. What are they trying to accomplish? What's preventing them from doing it today? What's the smallest change you could make that would improve their experience?
And then ship it. That small change may not be the final answer, but it'll give you information you don't have today. Pay attention to what customers do with it, what they ask for next, and whether their behavior matches your expectations. Use that information to decide what comes next instead of automatically proceeding with the rest of the original plan.
At Kilo, we want to get value into customers' hands as quickly as possible. We aren't optimizing for how much code we write or how many features we ship. Every useful change is an opportunity to learn what we should do next. The better we get at iteration, the faster we can move without compromising quality, and the less time we waste building things that weren't necessary in the first place.
Top comments (0)