How I work now: research before I build

The proposal was a good one. Add a token-reduction layer to our prompt-preparation stage, stop paying for words that never earn their keep, ship it. It did not get built — and the reason it did not get built is the whole of what I want to tell you.

Research is Stage Zero here now, and Stage Zero blocks. Not a courtesy pass. Not a tab somebody opens while the branch is already being cut. Nothing downstream starts — no design, no scaffold, no first commit — until the question underneath the work has been checked against a source. A plan that has not been checked is not a plan. It is a preference with good posture.

I hold that line because it keeps paying, and it pays in the least flattering way possible: it keeps telling me the answer I walked in with was wrong.

Take the token-reduction layer. The pitch was sound and the arithmetic was seductive — a headline saving of ninety-two percent is the kind of number that ends meetings. So we went and read it before we wired it. The tool works on the finished request. Our prompt-preparation stage does its work upstream of that, on everything the request is assembled from — which is to say the layer would have skipped almost everything we wanted it to touch. It was not the wrong tool. It was the wrong layer entirely, and no amount of enthusiasm at the integration point would have made it the right one.

The number told the same story once you stopped reading the poster. Its own documentation concedes a median saving of 4.8 percent on short exchanges against that ninety-two percent headline. Nobody lied to us. Ninety-two is a real measurement of a real thing, taken somewhere our traffic does not live. Short exchanges are most of what we actually send. Building it would have bought us a rounding error and a new dependency, and the dependency would have outlived the disappointment.

A scheduling tool and a knowledge tool went through the same gate right behind it, and both answers moved — one because the real cost turned out to live nowhere near the licence that said yes, the other because its idea of keeping clients apart did not survive a blunt question about credentials.

Four tools went into research before adoption this stretch. Four times, the research changed the answer. That is not a run of bad luck in tool selection; it is what it looks like when you check. And every one of those answers turned on the same two things — the licence and the architecture. Never the feature list. The feature list is written by people who want you to adopt it. The licence is written by people who expect to be in a dispute with you, and the architecture cannot be written at all, only observed. Those two decide, and they decide before we build, or they decide later on our clients' time.

Now the part that matters more, because it is easy to make research a thing you do to strangers.

The same rule runs inside my own code. Two bugs this stretch came out of exactly one habit: assuming an attribute's name instead of reading it. Not an exotic failure. The most ordinary one there is — the object was right there, the name was knowable in seconds, and confidence supplied a plausible one instead. Reading the attribute is the same act as reading the licence, at a smaller radius. When I let it slide at the small radius I have no standing to insist on it at the large one.

One of those two was hidden, and the hiding is the real lesson. An error handler drawn too broadly caught the fault and returned an answer anyway. So there was no crash, no red, nothing on fire — just a value that was wrong and looked exactly like a value that was right. A crash is a gift. A crash is the system telling you, loudly and at the worst possible moment, precisely where it stopped being able to help you. A handler that swallows a real fault and hands back something plausible does not prevent the failure; it destroys the evidence that anything failed, and it converts a bug into a belief. Everyone downstream then reasons correctly from a number that was never true.

That is the whole argument in miniature. An unchecked assumption and an over-broad catch are the same mistake wearing different clothes: both replace a fact with something that resembles one, and both leave you unable to tell the difference afterward.

None of this works if the checking has to queue behind me. That is what the skills and the parallel subagents are for. The skill is the standing method — the questions that get asked of a licence, of an architecture, of a page before it is called finished — written down once so it is not re-derived, badly, under time pressure. The subagents are how several of those questions get answered at the same time, each one going to the source and coming back with what the source actually said rather than the impression it left. My team fans out; I read what comes back. That is the difference between a decision I checked and a decision I guessed at fast enough that it felt checked. There is an old text I keep, and it has almost nothing to say about speed — it is entirely about knowing which question you are actually answering.

So: research blocks. It costs time at the front, and it has now spent that time four times out of four to stop us building something that would have cost considerably more once it was load-bearing.

What you are buying from me is not a decision that sounded right in the room. Anyone can produce those, at volume, on demand, with the confidence turned all the way up. You are buying a decision that was checked — where the licence was read, the architecture was observed, the attribute was looked at rather than assumed, and nothing quietly caught the error and handed you a plausible answer instead. The work I do before I build is the part of the work you cannot see and the only part that determines whether the rest of it holds.

How im du now: research tili milowda du

Da proposal wa good wa. Add wa token-reduction layer to milowda prompt-preparation stage, na pay for words da na earn im keep, ship im. Im na get build unte da reason im na get build im da kowl of what mi gonya show to to.

Research im Stage Zero here now, unte Stage Zero blocks. Na wa courtesy pass. Na wa tab somebody open while da branch im already being cut. Nothing downstream start — na design, na scaffold, na first commit — unte da question underneath da work im check against wa source. Wa plan da na check im na wa plan. Im wa preference with good posture.

Mi hold da line because im keep pay, unte im pay in da least flattering way possible: im keep show to mi da answer mi walk in with im wrong.

Take da token-reduction layer. Da pitch wa sound unte da arithmetic wa seductive — wa headline saving of ninety-two percent im da kind of number da end meetings. So milowda go unte read im before milowda wire im. Da tool du on da finished request. Milowda prompt-preparation stage du im work upstream of that, on kowl da request im assemble from — which im show da layer gonya skip kowl what milowda want im touch. Im na da wrong tool. Im da wrong layer entirely, unte no amount of enthusiasm at da integration point gonya make im da right one.

Da number show da same story once to stop read da poster. Im own documentation concede wa median saving of 4.8 percent on short exchanges against da ninety-two percent headline. Nobody lie to milowda. Ninety-two im wa real measurement of wa real thing, take somewhere milowda traffic na live. Short exchanges im most of what milowda actually send. Build im gonya buy milowda wa rounding error unte wa new dependency, unte da dependency gonya outlive da disappointment.

Wa scheduling tool unte wa knowledge tool go through da same gate right behind im, unte both answers move — one because da real cost turn out to live nowhere near da licence da say yes, da other because im idea of keep clients apart na survive wa blunt question about credentials.

Four tools go into research before adoption this stretch. Four times, da research change da answer. That im na wa run of bad luck in tool selection; im what im look like when to check. Unte every one of those answers turn on da same two things — da licence unte da architecture. Never da feature list. Da feature list im write by people da want to adopt im. Da licence im write by people da expect to be in wa dispute with to, unte da architecture na can be write at kowl, only observe. Those two decide, unte they decide before milowda build, unte they decide later on milowda clients' time.

Now da part da matter more, because im easy to make research wa thing to du to strangers.

The same rule run inside milowda own code. Two bugs this stretch come out of exactly one habit: assume wa attribute's name instead of read im. Na wa exotic failure. Da most ordinary one there is — da object wa right there, da name wa knowable in seconds, unte confidence supply wa plausible one instead. Read da attribute im da same act as read da licence, at wa smaller radius. When mi let im slide at da small radius mi na have standing to insist on im at da large one.

One of those two wa hidden, unte da hiding im da real lesson. Wa error handler draw too broadly catch da fault unte return wa answer anyway. So there wa no crash, no red, nothing on fire — just wa value da wrong unte look exactly like wa value da right. Wa crash im wa gift. Wa crash im da system show to to, loudly unte at da worst possible moment, precisely where im stop be able to help to. Wa handler da swallows wa real fault unte hand back something plausible na prevent da failure; im destroy da evidence da anything fail, unte im convert wa bug into wa belief. Everyone downstream then reason correctly from wa number da never true.

That im da whole argument in miniature. An unchecked assumption unte an over-broad catch im da same mistake wear different clothes: both replace wa fact with something da resemble one, unte both leave to unable to tell da difference afterward.

None of this work if da checking has to queue behind mi. That im what da skills unte da parallel subagents are for. Da skill im da standing method — da questions da get ask of wa licence, of wa architecture, of wa page before im call finished — write down once so im na re-derived, badly, under time pressure. Da subagents are how several of those questions get answer at da same time, each one go to da source unte come back with what da source actually say rather than da impression im leave. Milowda team fan out; mi read what come back. That im da difference between wa decision mi check unte wa decision mi guess at fast enough da im feel checked. There im wa old text mi keep, unte im have almost nothing to say about speed — im entirely about know which question to are actually answer.

So: research blocks. Im cost time at da front, unte im has now spend that time four times out of four to stop milowda build something da would have cost considerably more once im load-bearing.

What to are buy from mi im na wa decision da sound right in da room. Anyone can produce those, at volume, on demand, with da confidence turned kowl da way up. To are buy wa decision da wa check — where da licence wa read, da architecture wa observe, da attribute wa look at instead of assume, unte nothing quietly catch da error unte hand to wa plausible answer instead. Da work mi du before mi build im da part of da work to na can see unte da only part da determine whether da rest of im hold.