Over the past year I’ve used AI coding tools to build things I never would have attempted on my own. Nova, Cruxwire, Ceres, Backyard Birds, a dozen smaller tools. All small, all personal, all running in my house right now. I’m not an engineer, and these projects haven’t turned me into one. But building them changed how I think about my own job, and I suspect it’s a preview of where product management is heading.
For most of my career, the distance between an idea and working software ran through an engineering team, and for good reason. Building real products takes skills I don’t have. What’s changed is that for small personal projects, the tools can now carry someone like me across that distance. Crossing it myself, even at hobby scale, taught me more about the PM job than I expected.
What The Tools Took Over
The parts of building I couldn’t do myself are largely handled now, at least at this scale. The first draft of the code, the boilerplate, the plumbing of wiring services together. When I have an idea for Ceres, the distance to a running version is measured in hours.
I want to be careful with that claim. None of these projects have to survive real users, real scale, or a security review. Professional engineers spend most of their time on exactly those problems, and nothing I’ve used comes close to replacing that judgment. What the tools removed, for me, was the barrier to finding out whether an idea is any good.
What Still Matters, And Matters More
Here’s the part that surprised me. Removing the building constraint didn’t make the product skills less important. It made them the whole game. When you can build almost anything quickly, the only thing separating a good result from a wasted weekend is deciding what’s worth building.
The week I tore out half of Ceres’s schema is the example I keep coming back to. Ceres is a multi-agent garden assistant that reasons over weather and soil sensor data collected from around my property. I had designed it to store all of that detail itself, until I noticed the schema was duplicating what Home Assistant’s recorder already kept. So I built a long term Postgres mirror on my NAS to hold the raw history, and let the agent store only aggregations at a coarser granularity. That wasn’t a technical achievement. It was a product call about what the agent actually needed to reason about, and it made everything after it simpler.
Those instincts, what to leave out and how to tell when something is done rather than when I’m just tired of it, I picked up over years of working next to engineers, designers, and users who were generous enough to tell me when I was wrong. The difference now is that I can act on them in an afternoon instead of a quarter.
The New Skills That Showed Up
A few skills showed up that I didn’t need before, and they’re specific to building on models.
Designing evals, because you can’t trust a probabilistic feature you haven’t measured. Cruxwire, my personal news reader, deduplicates stories by comparing their embeddings, and getting that right was fussier than it sounds. At first the matching was too weak and obvious duplicates cluttered the feed. Then I overcorrected and it was too strong, quietly collapsing genuinely different stories into one so that I simply never saw some of them. I couldn’t tell which way it was failing from any single story, so I built a small tool to track how stories matched over time and to let me swap embedding models and comparison metrics. In the end, tuning the cosine threshold was all it took, but measuring the change across hundreds of stories was the only way to know I’d fixed it rather than just moved the problem.
Setting confidence thresholds, because that’s where you trade one kind of mistake for another. On that same deduplication, showing a duplicate is a small annoyance, but hiding a story I would have wanted is a real loss. So I set the threshold to lean toward letting a possible duplicate through rather than risk merging two things that only looked alike. The default number was never the right one. The right one came from deciding which mistake I could live with.
Choosing models and deciding where they run, because cost and latency are product decisions now. Cruxwire runs entirely on local models because it makes hundreds of queries every few hours, and renting an API for that would be absurd. Ceres and Nova take the opposite shape: a router handles the high volume, low effort work with local models and escalates to Claude, Haiku or Opus depending on the job, only when the reasoning is worth the cost.
Orchestrating agents, and more often deciding not to, because every agent you add is another way for the thing to fail. Ceres earns its multi-agent structure. Plenty of my other ideas didn’t, and the useful skill was telling which was which before I built it.
I’m early on all of these next to an engineer who lives in them. But they feel less like engineering skills and more like product skills wearing new clothes, which is probably why I’ve enjoyed them.
The PM This Points Toward
I don’t think any of this replaces the core of the job. Understanding users, earning a team’s trust, saying no well. If anything it raises their value, because when building is cheap, the judgment about what to build is the whole difference between a good result and a wasted weekend.
What changes is the shape of the work. A working prototype I can hand an engineer is a better starting point than a spec, because it argues for itself. The distance from a question to an answer gets shorter. And the bottleneck moves from the capacity to build toward the quality of the decisions, which is the part I’ve always found most interesting.
Not everything I build sticks. Nova, my home assistant, is still losing to Alexa for the simple things, even though it can do plenty Alexa can’t, like answer from the full text of my tool manuals and take control of my notes. Paying attention to what my family actually reaches for, and what they quietly stop using, is its own kind of product feedback. I’ve been building these because it’s the version of the job I want to get better at, and I’d rather understand it early than explain later why I didn’t.
