Last week, I introduced seeds, a CLI tool I use as a solo-dev to capture my deliberation with agents about features and ideas.

My Understanding of Current Thinking

As part of my development of seeds, I have begun to look for conversations surrounding how people are thinking about capturing the decisions and decision making process as they plan systems with the intent of having GenAI (Generative AI, e.g. agents) implement those systems. In the wake of Storey’s From Technical Debt to Cognitive and Intent Debt (the “triple debt” paper), people seem to be rallying around the term “intent debt” or rather the “absence of externalized rationale that developers and AI agents need to work safely with code.” Storey actually names three debts — technical, cognitive, and intent — and I’m setting cognitive debt aside here: that one is the internalized, shared understanding a team holds about a system, a different axis from the externalized deliberation seeds is built to capture. I like to think of intent as the “why” in “why did we choose this approach for the system”. A predominant attitude, captured well in Osmani’s The Intent Debt is “An agent can’t generate intent, because intent is the one input that has to come from you.” and that agents “will invent a confident-sounding reason, which is worse than admitting it doesn’t know.” The consensus seems to be that capturing intent and providing it to GenAI will help improve the decisions it makes while implementing a system. I agree with this notion. What seems to be lacking is consensus on how best to capture and represent intent, and that’s exactly the space I inadvertently started exploring when I began working on seeds.

When I introduced seeds, I described it as “deliberation software” but in a recent investigation into that terminology, I discovered that term is currently being applied to software that facilitates debate and decision making between sets of multiple AIs. That’s definitely not something seeds does, so at the moment, I see seeds as adjacent to “intent software” and will be exploring a more appropriate and permanent label for it. For now I will continue with using the term “deliberation” to represent “the messy, often non-linear, spaghetti-like process of exploring ideas about a system before deciding upon a particular approach to a problem.”

seeds is Upstream of Intent

To me, the conversation around intent is where/how to capture the sanitized, concise set of reasons behind the decisions that have gone into a system with the intent of helping keep GenAI on track. Indeed, the conversations I’ve seen about intent capture propose things like ADRs, BDD, AGENTS.md files, etc. All of these artifacts make the assumption that a particular approach has been decided and should now be recorded and enforced.

But for me, one of the most interesting and lossy parts of developing a system is discovering the approach to begin with, and that was the part I wanted seeds to capture.

I’d argue that intent isn’t even a complete picture. For instance, with seeds, my intention was to capture deliberation between a solo-dev and their agents. It’s a good intention. Now, how the heck was I going to do that?

I had to choose a language for implementation, a means of storing the ideas and deliberation, a way to structure that information, an interface for the agent to use, etc. Using Storey’s triple-debt framing, the closest approximation of what I’m describing is intent, but I can’t exactly see where all that deliberation is supposed to reside. I’m not going to pack an AGENTS.md file with something like this:

Well, I considered PostgreSQL, but that would require a user to set up a whole RDBMS system just to warehouse a couple hundred rows of data, so let’s use SQLite for now. Also, I thought about using Ruby because it’s my primary language, but ultimately decided to go with Python because LLMs seem most familiar with that language and this will be completely developed by GenAI. Also I think that a CLI over MCP is best because MCPs always take up context but a CLI can be interrogated on demand.

Some of that is intent, and some of that is vital historical information that has no place being loaded into my agents’ context each time it fires up. If we focus solely on “intent” we lose a lot of information I consider valuable. At the same time, if we capture all that information in a way that requires an agent to frequently review it and incorporate it into its context, we’re wasting tokens. Intention, the way people are talking about it and seem to want to use it as a means to inform GenAI’s behavior, should be streamlined, concise, and firm. But the process that gets us to that kind of intention is anything but.

I also find that intent is dynamic and emergent — something you often discover as you build, and revise as you go. Ball’s Building Software Is Learning does a great job explaining that building software is, in part, exploration and discovery — that you often can’t fully specify what you want until you’ve started building it. Particularly with seeds, I really had no idea if such a tool was feasible. My theory was that if beads could help an AI and human collaborate on implementation, perhaps I could build a tool that helped an AI and human collaborate on design and deliberation. I wanted to test this theory, so my original intention for seeds was to build an MVP of a tool that would then help me design the rest of that tool. My hope was that by using the tool to design more of the tool, I’d learn what was working, what was failing, and what was missing.

What I’ve Learned

Surveying the discourse surrounding intent debt has deepened my understanding of the problem space and given me some insights into where seeds fits:

The most surprising thing I learned — the intent was already reaching the agent. Intent can be (and, it turns out, is) a product of seeds, but it is not the sole focus of seeds. Across multiple posts, I saw authors postulate that by giving GenAI information about the intention behind what it was being asked to implement, GenAI would make better choices. As I mentioned in my previous post, I design a feature in seeds, then ask seeds to turn that design into a series of beads. I have never looked at the generated beads myself, because almost always GenAI was able to one-shot the feature I’d worked out in seeds. Why fix it if it ain’t broke.

But I became curious whether the intent in my seeds was actually reaching the agent, so I had an agent comb through how GenAI had been interacting with the beads. I figured that if the intent reached the implementer at all, it would be because the agent followed each bead’s back-references to the seeds it came from and read them. Or maybe I was doing such a thorough job speccing out every detail in seeds that GenAI had no need to make decisions at implementation time and never bothered with those back-links at all.

What the agent found surprised me: seeds had been quietly including a “## Why” section in each bead’s description, putting the intent behind the implementation directly into the bead. The GenAI had access to it all along — as plain tokens it reads by default — and that may very well be why it has been one-shotting with such regularity for me. I never would have thought to check before I learned about intent debt.

seeds is definitely a product of my environment - As I stated in the previous post, I am primarily a solo-developer. My boss is essentially my client. He and I communicate in either brief Slack messages or long, completely transcribed Zoom discussions. Any planning I do is in a conversation with an AI agent. All my deliberation about my software projects is therefore completely captured. This is essentially the world Haber describes in Everything Is Recorded Now — where you may as well assume everything you say at work is being recorded — except I’ve leaned into it on purpose. The common worry about that world is the “candor paradox”: once everyone assumes the meeting is recorded, the real, half-formed thinking tends to flee to the hallway and the DM, where no recorder is running. My setup doesn’t have those hallways; the candid conversation is the recorded one. That makes ingesting deliberation into seeds very, very low friction. If anything, I find myself calling out to AI in my conversations and Zoom discussions to “note this” when I want to flag something important for later ingestion into seeds.

I prefer live capture of intention over other approaches - Meta Engineering’s How Meta Used AI to Map Tribal Knowledge recently described inferring tribal knowledge — the conventions and constraints buried in code — from existing artifacts. Notably, that recovers what the code implies, not why the humans chose it. As I mentioned in the previous post, I have added seeds to a decade-old project, but I haven’t bothered to go back through and have seeds attempt to infer any intent. Capture from live sources feels like such a richer source of high-fidelity information and my plan for now is to simply capture deliberation on that project from here on out. Perhaps someday I will explore backfilling intent from other artifacts in the project, but it’s not interesting to me at this point.

seeds comes down on the “tokens” side of how to store and represent intent - Kellogg’s Agent Memory Patterns makes a pointed case that the only structure an LLM really needs is tokens — that knowledge graphs and SQL-backed schemas tend to fight the model, since its weights don’t know your schema. Now, seeds does store deliberation in a database, with a light amount of metadata and typed references between seeds — exactly the kind of structure Kellogg side-eyes. But that structure is storage-layer bookkeeping; it isn’t what the agent reasons over. What an agent actually works with is reassembled markdown — the body of each seed is a large blob of prose, pure tokens — so at the layer Kellogg cares about, seeds lands on his side of the argument. The structure just makes the right tokens findable, the way an issue tracker does. Whether even that light structure helps the agent or quietly fights it is a question I’m still chewing on. And fortuitously, seeds chose to generate beads with a simple “## Why” section, feeding that intent to the implementing agent as plain tokens in the bead’s description.

My survey of the conversation surrounding intent debt helped me better understand where seeds does and does not fit in the landscape, and turned up a couple of interesting avenues I might pursue. There’s a whole other side to keeping this upstream record — what you can do by going back and revisiting it later — but that’s a post for another day. For now, seeds continues to help me capture, organize, refine, and implement my thoughts about my various projects, and I hope you have a chance to try it out and see if it does the same for you. That, after all, is where I’ve planted seeds: upstream of intent, in the deliberation itself.