Building software
On Building Faster and Learning from Use

With coding agents, software engineers have more room to practice product judgment. When the small pieces of implementation take less time, we can spend more attention on the problem, the people using what we build, and whether the result helps them.
That opportunity interests me as much as the speed of writing code. It also comes with a catch: being able to make another improvement quickly doesn't tell us whether that improvement is worth making.
More room for product and design decisions
Coding agents can help with boilerplate, connect existing pieces, and make changes that would otherwise require a lot of small edits. Their output still needs review and verification. But reducing that work can make it easier to try a different interaction, simplify a workflow, or remove a feature that complicates the experience.
Engineers already make product and design decisions. Faster implementation gives us more chances to practice them. We can ask what someone is trying to accomplish, watch where they get stuck, and try an adjustment while the problem is still fresh.
Personal projects as a place to practice
There is another opportunity in the backlog of personal projects. An idea that once felt too expensive to try can become something usable sooner. That gives us a place to experiment with technologies and approaches, whether or not they involve coding.
A problem from your own life gives you a useful starting point. You know when it occurs, and you can try the result in the situation that prompted it. You may discover that your original idea missed an important step, added unnecessary work, or solved only part of the problem. Each revision becomes another chance to practice judgment.
My personal reading pipeline grew this way. It started with wanting to turn videos into something I could read offline, on printed pages like a newspaper. I first fed it individual videos, then made the summaries available to read on my Kindle. As I used it more, I added automatic fetching from YouTube channels.
From there, I wanted to read the same material wherever I was: on Kindle, on the web, or on my phone. Then I added ways to send material from the different platforms I used. The project evolved through everyday use. Each step came from a need I noticed while using the previous version.
The value comes from going through that process repeatedly. Finishing a prototype is one step. Using it long enough to notice where it falls short gives you something more specific to work on next.
Solving your own problem is useful evidence about your own needs. If you want other people to use the result, you need to learn about their needs too. They may have different habits, constraints, or expectations.
Product analytics tools such as PostHog can help you see which features people use, where they drop out of a flow, and whether they come back. For a reading app, you could track whether saving a link leads to opening its summary. That gives you a specific question to investigate. Talking to people helps you understand why they stopped and what they needed instead.
The temptation to keep polishing
"The perfect is the enemy of the good" applies here. Faster changes can make it tempting to keep adjusting a product before anyone has used it. There is always another layout to try or another feature to add.
If you are building for yourself, you can start with everyday use. Try it when you actually need it. Notice what you avoid, what you repeat, and what still requires a workaround. Those observations give the next iteration a reason to exist.
Before making another improvement, ask: What happened when someone used this that makes this change worth doing?