DEV Community: Bryant Hood

Cheap to Build, Hard to Kill

Bryant Hood — Tue, 29 Sep 2026 14:15:58 +0000

I built a tool that automates a piece of the financial close. The engine and the interface came together in a couple of days.

The other three-quarters of the time went to what nobody demos. Who can approve what. How every entry traces back to the model and the person behind it. How you prove a number came from the live system and not a stale test value someone forgot to rip out.

AI made the first part cheap. It did not make the second part cheap.

That matters if you are building a company rather than a weekend project. A solo builder with an AI coding stack can ship a believable version of most software in days. So the question is what still protects you once anyone can copy the features.

Most answers say data. Here is the 30-second test I use:

If every customer walked tomorrow and took their data with them, would what's left still be worth anything to the next customer?

If the answer is no, you are a landlord holding data your customers can carry out the door. Data protects you only when it is hard to copy, stays fresh, and compounds into something a newcomer can't shortcut.

The longer version, with the research behind the test: https://medium.com/@brnthood/cheap-to-build-hard-to-kill-5b87edfc27f2?sk=ca565a3cf255830a1bdec7349ce03008

Stop Doing It Manually: A Four-Step Framework for Building Your Own Solution

Bryant Hood — Tue, 29 Sep 2026 14:15:53 +0000

I kept forgetting to grab the AI summary before leaving a Teams call. So I built a fix.

The result is a small Windows program. It watches for a Teams call, records both sides, transcribes on my own machine, and writes a transcript with the Outlook meeting details already in it. The audio is deleted once the transcript lands. A tray icon and a folder of text files are the whole product.

I did not write it line by line. I ran it through four steps:

Notice and explore. Catch the thing you work around, then make the agent show you what it assumed.
Plan and premortem. Get the plan on the page, then send adversarial agents to poke holes in it.
Execute and test. Let the agent type, then run the thing yourself. Reading it won't tell you what running it will.
Deploy and maintain. Hand it to a machine that has never seen it.

One decision from the plan: I wanted AI summaries of each call. Turning that on meant transcripts leaving my machine, so the feature came out instead.

The same four steps gave me a lint script for my own writing, a wiki an agent maintains, and a task queue I no longer track by hand.

The longer version, with the plan file and the install lessons: https://medium.com/generative-ai/stop-absorbing-the-manual-work-four-steps-to-solving-it-yourself-99ac67f13a01?sk=ffe770bc6740373b16234205f90e6a5d

CLI: You don't need the interface

Bryant Hood — Tue, 29 Sep 2026 13:46:02 +0000

Every app charges you clicks to find what you came for. A designer who never met you decided where each button goes. The command line skips that guess.

The old barrier was memorizing commands. That barrier is gone. Your coding agent already knows them. I never typed one while setting up the routine below. The agent wrote each command, told me in plain English what it would do, and waited for a yes.

Three tools I use:

clasp pushes Apps Script to Google. My agent wrote a script that reads my inbox a few times a week and flags what I owe people. Filters move mail. They can't decide whether I owe someone a reply.
DuckDB queries a spreadsheet where it sits. Ask which vendors got paid twice last quarter. The agent writes the query and hands back the rows. Nobody types SQL.
pandoc converts documents in bulk. Forty Word files to PDF is one command, not forty rounds of Save As.

The rule I use: when the same clicks repeat every month, look for the back door.

One warning. Google shows a screen listing everything the script can read, edit and delete. Read it before you approve.

The longer version, with the exact prompts for each tool: https://medium.com/@brnthood/cli-for-when-you-want-to-take-the-back-door-a2433d9c6363?sk=b06a664c5aa32908e7614687d2723e77

I made my coding agent audit my prompt before it writes anything

Bryant Hood — Mon, 21 Sep 2026 13:14:15 +0000

The cost of a vague prompt is paid at the end, not the start. You learn what the model assumed only after it has finished building on the assumption.

That is the problem worth solving. You write down your intent, the agent acts on what you wrote, and whatever you left out gets inferred. The gaps never announce themselves. The model reaches for the reading its training makes likeliest, which is a decent guess about the average requester and a worse guess about you.

So I built a skill called clarify. It is a set of standing instructions the agent reads first, and it can also be called as a /clarify command. Before work starts, it audits the prompt for every assumption it would otherwise fill silently, surfaces them, and does not proceed until I answer.

The part that makes it usable

Auditing every gap would be unbearable. A prompt has dozens and most of them do not matter. So the skill sorts each assumption into three bands:

Settled. Only one reading survives. It proceeds without asking.
Defaulted. It picks the likely reading, states it out loud, and lets me veto.
Open. Two readings would change the deliverable. It has to ask.

Only the open ones become questions. That is the difference between a clarifying step you keep and one you switch off after a day.

The line the whole thing turns on

From the skill file:

The enemy is not ambiguity, it is silent inference. An expert's prompt is compressed: what they don't say is not absence of intent, it is unstated intent. Recover it from them; do not reconstruct it from your priors.

A compressed prompt is not a bad prompt. Treating compression as absence is what produces confidently wrong work.

Where it is

Public, free, no signup: https://github.com/bryanthood-wph/clarify

Drop it in and call it. It works as a skill file, and the /clarify command is the same instructions on demand.

The longer argument, on why a prompt is the cleanest record of your own blind spots, is over here: https://medium.com/@brnthood/account-for-what-your-prompt-doesnt-say-b443fa3af231?sk=504afa509c9d9df58dbff3290df992a3