Voice made my idea system start working

I have finally got an idea system that I am actually using, and the important part is not that it lives in Linear. The important part is that I can talk at it.

That sounds like a small distinction, but it is the whole thing. I have tried Trello. Other task managers too. I have kept lists of blog ideas, build ideas, and life-admin ideas in places that made sense for about a week. They all failed in the same boring way: I did not check them, so they stopped being part of my working memory.

The new version works because voice and LLMs have made both sides of the loop much cheaper. I can capture an idea by rambling from my phone. Later, an agent can read the ramble, understand enough of it, and turn it into a project, a draft, or a clearer ticket. The text may be slightly worse than if I sat down and carefully wrote everything by hand. That is fine. The careful manual version usually did not happen.

Linear is the ledger, not the magic

My setup is deliberately plain. Linear is acting as a personal idea ledger, not as a serious project-management system.

The useful shape is small:

• areas like Build, Writing, and Life/Admin
• a status model that is basically Idea to Done
• no labels by default
• no dependence on an inbox I need to remember to clear
• agents doing the reading and routing when I want to act on something

That last point is the reason it feels different from every previous version. A tidy board is not enough for me. A tidy board still expects me to come back, remember the context, sort the note, and decide what it means. That is exactly where a lot of my systems fall apart.

The change is that the interface has moved closer to how my brain already behaves. I can speak an untidy thought into Wispr Flow, get it into Linear, and let the next step happen later. The captured note does not need to be polished. It only needs to be good enough for a future agent, or a future me with an agent, to recover the shape of the idea.

I do not think Linear itself solved the problem. If I had to hand-write every issue, label it, groom it, and remember to review the board, this would probably collapse like the others. Linear happens to be a good ledger because it has stable issues, statuses, links, and integrations. The workflow works because I am not treating the app as the primary interface.

Worse input, working loop

The trade-off is obvious: dictation and LLM-shaped notes are messier than careful writing.

I am accepting that trade-off because the alternative was not "perfect notes". The alternative was missing ideas, scattered notes, abandoned boards, and the vague guilt of knowing I wanted to write and build more than I actually did.

This matters especially for ADHD solo building. The problem is not only storage. Storage is cheap. The problem is retrieval, re-entry, and momentum. A note that requires too much ceremony to capture is gone before it exists. A note that requires too much ceremony to reuse becomes archive dust.

The voice plus LLM version lowers both costs. Speaking is fast enough that capture can happen before the idea evaporates. Agent reading is good enough that the note does not need to be written like a specification. I can give Codex a Linear ticket full of my own rambling and it can usually find the important bits without the context becoming bloated.

That is the part that feels new in 2026. I tried related shapes before, but the technology was just short of good enough. The rough edges mattered. Now the combination of dictation, ChatGPT-style tool integrations, and coding agents that can read project context has crossed a threshold for me.

Not a magical threshold. A practical one.

The ticket became the post

This post is part of the evidence.

The original note was BIL-6, a Linear issue called "Blog idea: Lowest-friction idea capture workflow with Linear and agents." I made the note from my phone a day or two before writing this. It was not a polished brief. It was a captured thought: brain to Linear to later action.

Then I asked Codex to write from that ticket. It fetched the issue, pulled the angle, noticed that the ticket alone was not enough to draft responsibly, and asked me for the missing judgement: who this was for, what had failed before, what I believed now, and what the post should not claim.

That is a much more useful failure mode than either of the old ones.

The old manual failure mode was that I never came back to the note. The bad automation failure mode would be an agent turning a rough idea into generic content without checking whether it had my actual judgement. This version sat in the middle: the ticket carried enough context to start, and the agent knew when to ask for the human part.

That is the workflow I want more of.

The same thing is already visible in a couple of completed Linear tickets. BIL-5, created on 29 June 2026, became the agent-autonomy experiment behind LLM Choice is mostly an idea engine. BIL-8, created on 30 June 2026, became the site graph work I wrote about in I added a graph because the site needed some shape.

Those are not proof that the system is mature. They are proof that ideas are making it through the loop instead of sitting in a forgotten list.

For me, that is the metric that matters first.

The board should stay underdesigned

The tempting mistake is to respond to a working system by designing a more impressive one.

I could add a careful taxonomy. I could make labels for every kind of idea. I could add statuses for triage, drafted, blocked, delegated, researching, maybe, someday, and regrettably too many other shades of "not done". I could build the kind of system that looks impressive in a screenshot and immediately becomes another place to avoid.

I am trying not to do that.

The useful version is intentionally underdesigned. Capture first. Keep the statuses boring. Avoid labels until a repeated need appears. Let the system grow around real friction instead of imagined productivity structure.

That last phrase matters. I have wasted a lot of time solving the problems a perfect future system might have. The system I actually need has a smaller job: catch the idea, keep it findable, and make it cheap to hand to an agent when I have enough energy or curiosity to continue.

If a category becomes useful because I keep searching for it, I can add it later. If a status becomes useful because work is actually getting stuck between two repeated states, I can add it later. But I do not want the capture step to pay for structure that has not earned its place.

Agents make checking less necessary

The reason this feels so different from old task management is that I no longer need to be the only reader.

That sounds minor, but it changes the emotional shape of the system. A private idea board used to become another inbox. Even if I captured everything, I still had to go back and inspect the pile. If I did not, the board became stale, and then checking it became unpleasant because it was full of old versions of myself asking for attention.

With agents, the board can be more like a source of context. I can ask for writing ideas, project candidates, or the next thing to build. I can point the agent at the ledger and let it summarize, choose, group, or execute from selected tickets. I still make the judgement calls. I still decide what to publish. But I do not have to manually rehydrate every old note before anything can happen.

That is why the roughness is acceptable. The note is not the final artifact. It is raw material.

For a lot of neurodivergent workflows, that distinction is the whole game. A system that expects perfect human upkeep is fragile. A system that accepts messy input, can be queried later, and can help with the next action is much closer to how I need tools to behave.

What I would tell someone like me

I would not start by copying my exact Linear setup. I would start with the friction.

Where do ideas currently disappear? Is capture too slow? Is retrieval too annoying? Does the system depend on an inbox you already know you will not check? Does every note need to be named, tagged, or sorted before it feels allowed to exist?

Then make the loop smaller.

For me, that currently means Linear as the ledger, Wispr Flow for voice capture, and LLMs or agents for reading the notes back into useful shape. Someone else might use a different app. The app matters less than the path from thought to recoverable context.

The rule I am using now is this: if a workflow works only when I become a more consistent person, it is probably the wrong workflow. If it lets me stay myself and still get ideas into motion, it is worth protecting, even when the output is a little rougher.

This is early. I am not claiming I have used this system for years, or that it removes every issue, or that Linear plus agents is the universal answer. I am saying that, for the first time in a long time, my idea system is not mainly a place where ideas go to disappear.

The next step is to keep it deliberately small until repeated friction earns more structure.