AI Engineering Practice
Agent tooling, publishing pipelines, licensing and prior-art discipline: the working practice around building with AI.
12 pieces
Every piece in this topic argues the same asymmetry. Checking a license before the install takes thirty seconds. Reconstructing why a dependency is in your tree two years later, with a patent attorney reading your requirements file, takes weeks, and you do it with worse information than you had at the time.
That shape repeats everywhere. Logging what you read before you write the code is cheap. Litigating your own mental state from memory is not, because memory loses to a timestamp every time. Writing the plan down as an artifact costs ninety minutes. An agent that executes brilliantly on the wrong plan produces perfect garbage, and you find that out at hour three.
So the discipline here is not caution. It is recording the decision at the moment you have it, while it is still free. A license gate that runs before adoption, because GPL v3 patent retaliation and the two-way grant in Apache 2.0 are properties you check, not footnotes you reconstruct. A prior-art ledger in version control, because reading competitors is the protective move and the danger is honest reading with no contemporaneous record. A conception matrix, because under first-to-file the clock starts at filing and that evidence has exactly one live use.
The agent work follows the same rule at a different scale. You do not hand-design a fleet, you design the specification that generates it, and the spec carries the failure contract or the fleet cascades in a way that surfaces far from where it broke. Plans land only on the convergence of two independent councils, because one reviewer who shares your context is barely a filter. Rules load where they apply rather than always, because completeness that collapses into always drops the signal it was meant to carry. Installers ship their uninstall path beside them.
And you write the postmortem even with nobody to circulate it to, because a solo builder has no institutional memory and the document is the institution. Same reason you audit before you refactor: the mental model you built six months ago is six months stale, and the gap always exists. The only question is whether you know about it.
What connects all of it is a loop rather than a domain. Frame the problem sharply, find the prior art, set the quality gates, put the machines to work, audit what comes back, write down the lesson. The domain rotates weekly. The loop compounds for years. And the faster the code appears, the more the verification matters, because speed without gates is just confident garbage.
The pieces
- Solo founders don't write postmortems. They should.
There was a morning my machine just stopped working.
- Rules That Know Where They Are
Every session I opened, the same thing happened. The AI assistant loaded, and with it came the full operating rulebook for everything I might ever do: Salesforce org safety guards, publishing pipeline discipline, agent self-star taxonomy requirements, UI typography standards, concurrency policy, IP firewall rules. All twelve thousand tokens of it. Every time. Whether I was writing a LinkedIn…
- I shipped a broken plan. Then I built the pattern that would have stopped it.
Three in the morning. I had just approved my own plan. Not reviewed it, approved it. My tired brain said it was solid. The agents started executing. By morning I had a beautifully built implementation of the wrong thing.
- Discover Before You Refactor
There is a specific feeling when you open a codebase intending to clean it up. Almost smug. You remember writing this thing, or you've read it before, and you can already see the problems from the doorway. The function names are too long. The abstractions leaked in the wrong direction. There's that one class that does eleven things and everyone's afraid to touch.
- From One Spec to Two Hundred Agents
There is a moment in every serious multi-agent project where someone finally says the quiet part out loud.
- A conception-evidence matrix for solo inventors
Most solo inventors misunderstand first-to-file the same way: they think the clock starts when they had the idea. It doesn't. Under the AIA, the clock that matters is when you file.
- A reversible installer for your CLI config
Every CLI installer I've ever run leaves a question hanging: what exactly did it touch, and can I get back? I've been burned enough times (clobbered configs, mystery overwrites, a setup that "worked" until the moment I tried to undo it) that reversibility stopped being a nice-to-have. It became the first constraint I wrote down.
- Random Work Is the New Deep Work: Notes on the IQ → EQ → AQ Shift
My work journal writes itself: every session gets captured by a hook, and a nightly job distills the day into one page. Eighty-four entries since April 4. This morning I scrolled back through all of them looking for a through-line, and the honest answer is there isn't one. An EDI acknowledgment loop on a Monday. A drift detector for model routing on a Wednesday. License hygiene on a Friday. A…
- Apache-2.0 is a two-way patent grant, and the second way can bite you
> Disclaimer: I am not a lawyer and this is not legal advice. This is a reading of what the license text plainly says. For any real IP decision, consult a qualified patent attorney.
- The 30-second license check I run before every pip install
> Disclaimer: I am not a lawyer and this is not legal advice. This is a reading of what license texts plainly say. For any real IP decision, consult a qualified patent attorney.
- The GPL v3 patent trap nobody checks until a lawyer walks your requirements.txt
> Disclaimer: I am not a lawyer, and nothing here is legal advice. What follows is my reading of what these license texts actually say in plain language, and the patent implications that seem to follow from that text. For any real IP decision, take it to a qualified patent attorney. On a public page a wrong legal claim is worse than a cautious one, so I am going to stay close to the words on the…
- A Prior-Art Discipline for IP-Sensitive Builders: Reading Competitors' Code Safely
Picture the worst version of a deposition. You are three years past the build, sitting in a conference room you do not own, and opposing counsel slides two printouts across the table. One is your git history. The other is your browser history. They are not accusing you of copying a single line of code. They have something quieter and worse. A highlighted row on each page, and a date that lines…