Collimate · Why it exists
Worth Throwing Away
I started getting quietly irritated every time autocomplete text showed up next to my half-formed sentences.
It was hard to say why, because it was right. Grammatical. Plausible. Ready to go. The tool was doing exactly what it promised, and accepting took one keystroke.
Before I'd finished deciding what I meant, the tool had concluded that my contribution was approval. A half-formed thought had become a request for a verdict.
Writing is one of the ways I find out what I think. I start a sentence, get stuck, change a word, and discover I believe something slightly different. There is work happening in that hesitation. The tool treated it as latency.
A small annoyance, at the smallest scale. But scale it up and the shape reappears. An agent that refactors a module, a chat that drafts a strategy, a pipeline that produces a whole deck: at every size the tool hands over a finished thing and waits for the same keystroke. The model drafts, and I approve.
The working style we fell into
Making the draft used to be the hard part. So we worked straight toward the thing someone else would consume: the diff that merges, the deck that gets presented, the essay that gets read. Every tool we had was built around one precious artifact, and the only sensible question was how far along it was. That is how we were trained to work, and now it is what we ask the model to do.
An agent works through your codebase making optimizations. A chat hands you a compelling essay for a viewpoint. The onboarding copy says to treat it like a junior employee: the same way of working you have always had, except now you are the supervisor.
You can manage the junior by giving precise instructions and specifications. You can manage it by having it redo the work against your feedback, over and over. These are presented as the two ends of a spectrum. They are the same position.
Both cast your judgment as something to supply: in the spec before the work, or in the verdict afterward. You can learn while writing a spec, or be surprised into a different view by a draft. The interface still asks what you want and whether this is it.
That is useful when you know what you want well enough to hand it over, and much of the time you do. Most tasks have a right answer, or a good-enough one, and the oracle is the fastest way to it. I'm not arguing against that. I'm arguing about the other case, the one where finding out what you want is still part of the work, and about what happens when a tool built for the first case is the only tool you have for the second.
Hard problems
A hard problem rarely has one right answer waiting for a smarter system to find it. It has trade-offs. Every good approach spends something: maintenance risk, downtime, performance, compatibility, someone's convenience at the cost of someone else's. A trade-off has no solution, only a chosen point on a curve.
When the model hands you one answer to a problem like that, it hasn't found the answer. It has picked a point, on axes it chose, and presented the result as the destination. And the more convincing the answer, the harder those choices are to see, and the easier it is to begin thinking inside its account of the problem.
The same thing happens to whatever you brought in. Offer a tentative framing, or a spec, and ask whether you're on the right track. What comes back is a developed argument for your premise, with very little in it about whether the premise holds. Refine it together. With each exchange the idea grows more coherent and more familiar, and you can travel a long way like this while learning nothing.
Accidental thinking
Drafting was where judgment used to come from. Judgment forms in response to what you encounter. A comparison forces a preference. A failed experiment sharpens a question. Working on a detail exposes an assumption you'd never have thought to check. None of this was designed. Thinking was a byproduct of drudgery, and the drudgery was mandatory, so the thinking was too.
The tool decides which of those encounters happen. A tool built for a supervisor gives you one encounter, over and over: here it is, yes or no. And once you're holding the thing, every reaction becomes an edit to it rather than a decision among things.
It is a choice to work this way, to ask the model to solve. You could ask it for the possibilities instead. You'll throw most of them away, and that's how you find the one worth keeping.
Moves to make easy
It starts with taking temporary artifacts seriously. Real effort that exists to be thrown away, because it moves you along the problem you actually care about. Not the app, but a set of scaffolds to think about the architecture with. Not the game with the new mechanic, but a single level with a dozen jump variants on it, to find the feel. Not the essay, but the major camps of thought on the subject and how each would react to the argument you're considering. You might go into that level comparing jump heights and come out caring more about control in the air.
A hundred-widget page can cost more than a first draft of the app and still be worth making. These artifacts are lopsided: maximal along the axis of your question and absent everywhere else. Spend attention where the answer changes the most downstream, where the consequence is highest and what you know is lowest.
What that asks for is exploration, and exploration has a shape. You make artifacts in different directions. You widen what you can see. You attack what you found, to learn whether it holds. And you leave with what you found, from wherever on the journey it turned up. A tool that supports this has to make four moves easy.
Forking. Some tools already fork: run the same task on several models, lay the results side by side, keep the best. That helps find a good result within one framing. The prompt stays fixed and only the solver changes. Picking a winner can end the comparison before you've learned much from the alternatives.
Forking in the middle varies the framing itself: a different assumption, a different axis, a different idea of what counts as a cost. Say you're building a demand forecast for thousands of products. Fork there three ways: one model minimizes average error across products; one treats underestimating demand as more costly than overestimating it; one learns only from recent sales and updates often. Test all three on the same test periods, comparing their errors, stability, and upkeep. One kind of fork reduces variance around an answer. The other widens the question on purpose.
Seeing. Take a philosophy essay. You could look at a map of the major lines of thought, see where your argument sits and who it's arguing with. You could overlay the essay with a heatmap of the claims most likely to be contested, and find that the premise you've taken for granted is where the argument is weakest. Yet the interface gives you a single document and a place to add comments that spawn more text.
A tool that offers one view has already decided what matters. It has to make it easy to ask for a useful view in the middle of the work, and to return to it without rebuilding it.
Challenging. It should be the easiest thing to do with a model, and it is made hard. Ask about latency just to understand a choice, and latency becomes a design pillar. Question one claim, and the whole answer grows hedges. Your curiosity gets filed as a requirement.
Seeing describes the work; challenging takes a side against it. A challenge fails by never being an adversary at all: either it inherits the session's premises and argues from inside them, or it concedes on contact and starts fixing. It needs a position outside the session, with no obligations to the artifact and one brief, to oppose. A question can stay a question there until you decide what to do with it.
Picking. There is always another variation available, so leaving takes its own judgment: what more exploring would plausibly yield, what the work needs now, what you'll only learn by putting it into use. Often the cut comes not because the answer revealed itself but because none was going to.
And the pick is often from history: the version that seemed not good enough at the time, or the revision before you smoothed over the text and lost your voice. Anyone who has worked on something for a while knows the sinking feeling of realizing the best version was three steps back, overwritten by its own improvements.
The tools that do keep history can still make you work to use it this way. Git keeps commits; document editors keep revisions. You can go back, compare, and recover pieces of an earlier idea, but those possibilities often sit apart from the work in front of you. Earlier versions should be easy to browse alongside the current one, and their useful parts easy to bring forward.
A tool that lets you generate variations cheaply but doesn't let you manage them has only built half of the move.
Won't better models solve this?
The obvious objection: isn't this scaffolding for immature technology? Once the models are good enough, won't they explore the alternatives, flag the weak assumptions, test, and hand you the proven solution?
They should. A model that explores on its own is exactly what I want in the loop. Nothing here is an argument about what is uniquely human. The argument is about where the result of that exploration lands, and the answer doesn't change with the model.
Some of what matters only becomes clear through the work. A comparison can change what you care about. The preference an explorer would need in order to pick for you may only emerge when you see what it found. If the interface hides the alternatives, you lose access to the differences that might have changed your mind. A perfect explorer behind a yes-or-no gate is still a gate.
The work I care about is knowing what you don't know and figuring out what matters: being confronted with the piece that doesn't fit and reworking what you brought in, rather than bending the new piece until it looks like the old shape. For that, I want a cadre of explorers: mapping the frontier, eliminating the dominated options, surfacing the trade-offs, and making visible what each assumed and where it settled for good enough.
Then the direction is yours, and it doesn't have to be one the map showed. You may finish with a different problem than the one you started with.
Out of the gate
Collimate is a verb. It means taking divergent rays and making them parallel, so they run side by side.
That is what I want from an AI tool: a place where the model's abundance gets aligned into something I can see across, compare, challenge, and cut. What I gain is a better result and a better understanding of why I chose it.
Judgment develops through a way of working: what you get to look at, and what you are asked to think about. Change that structure and you change the judgment that comes out of it.
I'm building Collimate for that.