I Stopped Asking My AI to Write. I Started Asking It to Decide.

Image placeholder

Editorial, product-forward hero illustration on an off-white background. LEFT HALF: a soft speech bubble with four or five wavy horizontal lines inside it, labelled 'WRITE' in a thin uppercase caption above. CENTER: a crisp horizontal arrow pointing from left to right, drawn as a thin emerald rule with a small triangular tip. RIGHT HALF: a compact typed form or receipt with three labelled rows (e.g. 'verified: ✓', 'score: 78', 'collection: Craft'), labelled 'DECIDE' in a thin uppercase caption above. Thin pale slate separator rules frame each side. Palette strictly off-white background, pale slate grays (#cbd5e1, #e2e8f0), emerald green accent (#10b981) for the decide side and the arrow, navy ink (#0f172a) for labels, one blue accent (#2563eb) for the score row. Clean, flat, geometric. Linear or Stripe editorial feel. No AI robots, no neural networks, no faces, no brains.

• Aspect ratio: 16:9
• Source size: 1600 × 900 px (sharp on retina at 760 px display width)
• Format: WEBP (preferred), PNG fallback
• Target file size: under 300 KB

Save to /public/images/blog/<slug>/, then set src and alt on this <MediaFigure /> to swap it in. Keep the ratio prop so the browser reserves the right space.

By Dr. Sanju Abraham, Fractional CTO — 180+ projects shipped, 34 funded companies. Published October 7, 2026.

Key takeaways

• I used to ask an AI to write me a paragraph and then write code to parse that paragraph. The parsing code was always more fragile than the AI.
• I noticed I was writing the same shape of parser five times in my book platform. Quote checks, metadata calls, section-quality scores, priority rankings, and collection assignments all consumed AI output as data, not prose.
• I moved all five to a decision model and renamed the pattern “the shape-first flip” — declare the shape of the answer before you write a prompt. That one reordering changed how I design every AI call.
• The downstream code got simpler, not harder. Typed answers and probabilities replaced regex-and-pray; tests became assertions on values; the retry logic quietly disappeared.
• I did not stop using chat models. They still write the drafts, the hover rewrites, and the reader-facing explanations. The decision model lives underneath for the five calls where no human was ever going to read the answer.

The short answer: For a year I asked a chat model to write me explanations and then wrote code to pull values out of those explanations. One week in the spring of 2026 I realised the parsers I kept rewriting were the actual product and the prose was scaffolding. I moved five decisions in my book platform — quote checks, metadata calls, quality scores, priority, and collection assignment — to a decision model that returns typed values with confidence scores. The mental shift behind that move is what I now call the shape-first flip, and it has reshaped how I design every new AI call since.

If you want the day-in-the-life tour of the same migration — three of the five decisions, walked through with code shapes and before/after thresholds — read how I use a decision model in my own product. This piece is the companion to that one: not the implementation tour, but the conversion story. What changed in my head when I stopped treating AI output as prose and started treating it as data.

Why did I stop asking my AI to write?

Because the writing was never what I actually wanted. I wanted the number inside the paragraph, or the label inside the sentence, or the yes/no inside the hedge. The paragraph was a shipping container I was paying tokens to generate and tokens to tear open.

Here is the pattern I kept catching myself in. I would wire up a chat completion with a careful prompt: “On a scale of 1 to 100, rate the craft of this section and explain your reasoning in two sentences.” The model would come back with a lovely little essay that ended with “I would give this a 78.” I would write a regex to pull the 78 out. Three weeks later the model would phrase a borderline case as “I would say this is somewhere around 75 to 80,” and my regex would miss it, and a book section would land in the wrong queue, and I would spend an afternoon tightening the parser. The explanation was never for me. The explanation was the model talking to itself with my code eavesdropping.

Once I saw it in one call site, I saw it in all of them. The whole middle layer of my product — the parts between the author’s input and the reader’s output — was a stack of parsers wrapped around a chat model I was asking to decide, badly, in prose. For the general-audience version of this diagnosis, see chatbot vs decision model: what’s the difference?. For the taxonomy of answer shapes a decision model offers, see the three questions a decision model can answer.

What is the shape-first flip?

The shape-first flip is a reordering of the first two steps of designing an AI call. Before: write the prompt, then figure out how to parse the answer. After: declare the shape of the answer first, then write a prompt that fills that shape in.

That sounds like a tiny procedural detail. In practice it changes everything downstream. When the shape is the first thing on the page, three awkward conversations go away at once. You stop arguing about tone, because tone is not an output. You stop apologising for strictness, because the schema is doing the strictness, not the prompt. And you stop debating fallback behaviour for malformed responses, because malformed is no longer a category — the shape is enforced by the model’s output contract, not by your regex.

I kept the mental image simple. In a chat call, I write a letter. In a decision call, I hand the model a form on a clipboard and say fill this in. The form is the shape. The model is still a smart generalist, but it is answering a bounded question, and I know what the answer will look like before I ever read it. This is the same pattern described in the OpenAI Structured Outputs guide and the Anthropic strict tool use docs; I settled on TypeSafe AI’s Jev because its three primitives — Choice, Score, and Noul — match the three questions I was actually asking at each of my five call sites.

The flip is also why this piece is not a product tour. The product details are in the companion article and in not every AI needs to talk. This piece is about the ordering of thought.

The five decisions I moved

I moved the five places in my book platform where downstream code — not a reader — was consuming an AI answer. Each one was a different shape; none of them wanted prose. Here is the honest list, in the order I migrated them.

• Quote checks (Verify). Before publishing a pulled quote on social or in a reader preview, I need to know the quote actually appears, verbatim, in the source book. The old version was a chat prompt asking “Does this quote appear in the book? Explain.” The new version is one Verify call returning a probability. Above 0.9 the quote ships; between 0.6 and 0.9 a human reviews it; below 0.6 the pipeline picks another candidate. The three-way routing is the pattern I wrote about in why “70% sure” is more useful than “yes”.
• Metadata calls (Choose). Every finished book carries a short set of structured metadata — genre tag, reading level, tone label — that drives filters and recommendations. The old version asked a chat model to “describe the book’s genre and tone in one paragraph.” I would then try to coerce the first noun phrase into a tag. The new version is a bundle of Choose calls against bounded enums I defined up-front. One call, N answers, all typed.
• Quality scores (Rate). For the sampler surface, I grade each section’s craft on a 0–100 rubric with written anchors at 20, 50, and 80. The old version was a chat prompt asking for a numeric score and a short explanation; the number was buried in prose and the scale drifted every time I touched the prompt. The new version is a Score call that returns an integer and a confidence. The explanation only exists for the sections a human is going to look at.
• Priority (Rate). The authoring dashboard shows an author’s unresolved revision requests sorted by priority — a 1-to-5 ordinal informed by things like whether the request blocks publication, how fresh it is, and how severe the issue is. I used to generate priority with a chat model and a messy “rate 1 to 5” prompt. Priority is now a Rate call on an anchored rubric, and the sort is deterministic given the same input.
• Collection assignment (Choose). At publish time, each finished book lands in exactly one reader-facing collection — Craft, Story, Field, or Memoir. Two humans used to argue in a Google Doc. A Choose call now proposes one of the four with a confidence number; the editor confirms with one click. The one-click confirm is a feature, not a workaround — it is the sensor that tells me when my Choose rubric is drifting.

The quiet pattern across the five is that none of them have a human reader. Readers see the published quote, the collection shelf, the sampled section. They do not see the decision that put those things in front of them. That is exactly the territory where the shape-first flip pays rent, and it is why I did not touch the places where readers do see the AI’s words.

What changed in my code once answers had shapes?

Four specific things changed, and none of them is the one I expected. I expected speed. I got speed, but the speed was the smallest of the four.

• The parser folder shrank until I deleted it. Every one of the five call sites had its own small parser — markdown-strippers, number-extractors, hedge-detectors, retry wrappers that re-asked the model when it answered in Spanish. All of that lived in a src/ai/parsers folder I was quietly embarrassed about. The folder is gone.
• Tests became assertions, not arguments. Before, my tests were regexes over paragraphs with brittle expectations about which words the model would use. I marked them flaky more often than I actually fixed them. After, I assert that the Choose returns "Craft" on a golden book and that the Score falls inside a sanity band on a golden section. The suite stopped being a theological debate and became a build gate.
• Costs stopped mattering as a line item. Decision calls bill short structured outputs, which is what my workload is. Jev’s launch pricing of $0.042 per million input tokens with output tokens free is published in TypeSafe’s launch coverage; for a quote-check that fires on tens of thousands of candidates a week, that moved from “watch the dashboard” to “stop watching the dashboard.” The cost drop was real; the attention drop was more valuable.
• I got my planning time back. The chat-model era of my product forced me to budget prompt-iteration time into every feature. The decision-model era does not. I write the schema in an hour, call the API, and ship. The hours I used to spend wordsmithing refusals back into compliance are now hours I spend on the product.

The speed improvement is real too — short typed outputs come back fast, and the user-visible paths that depend on them feel snappier. But if you had asked me a year ago which lever would matter most, I would have said latency. The thing that actually mattered was reclaiming the planning hours.

Image placeholder

Infographic: a vertical column of five rows representing the five decisions. Each row is split in two. LEFT HALF of each row shows the 'before' shape — a chat bubble with wavy prose lines, a tangle of connector arrows going into a small 'parser' box, and a human-review step. RIGHT HALF of each row shows the 'after' shape — a single arrow going from a question card to a typed value card (label, number, or probability) consumed by a downstream code icon. Rows are labelled Quote checks, Metadata, Quality scores, Priority, Collection. A thin header at the top reads 'BEFORE: write + parse → AFTER: decide + consume'. Palette: off-white background, pale slate borders, emerald accent for the after side, navy ink. Clean, flat, geometric. No AI robots.

• Aspect ratio: 16:9
• Source size: 1280 × 720 px (sharp on retina at 760 px display width)
• Format: PNG
• Target file size: under 500 KB

Save to /public/images/blog/<slug>/, then set src and alt on this <MediaFigure /> to swap it in. Keep the ratio prop so the browser reserves the right space.

Why the decision model does not replace the chat model

The shape-first flip is a tool, not a worldview. It is wrong to apply it everywhere, and I would be writing a worse product if I had.

The author-facing drafting workflow in my platform still runs on a frontier chat LLM. So does the hover-rewrite feature, the longform explanation that greets an editor opening a flagged section, and the one-paragraph “why we recommended this” blurb on the sampler. All four surfaces are read by a human. Prose is the point. If I squeezed those into a schema I would be shipping a worse experience to save on tokens that are not expensive to begin with.

The split I now carry in my head is embarrassingly simple. If a human reads the answer, it is a chat problem. If a function reads the answer, it is a decision problem. That one-line rule has survived every design review in my product for seven months. I use it to decide which API to reach for before I write a line of code. For the longer version of the rule — same split, more worked examples — see chatbot vs decision model: what’s the difference? and the broader case in not every AI needs to talk.

What would I tell myself to do differently?

Three things, all of which I did eventually and should have done sooner. The common thread is that each of them is cheap, and each of them paid for a quarter of engineering time I later spent cleaning up.

• Write the schema before the prompt. The hour I spent naming the four collections (“Craft, Story, Field, Memoir — these four, forever”) was the single highest-leverage hour of the migration. Every ambiguity downstream traced back to a sloppy enum upstream.
• Build the human-review surface on day one. I shipped the auto-confirm path first and bolted on human review later. In hindsight, the review queue is the sensor that keeps the model honest; I needed it from the start. Not a nice-to-have — a precondition.
• Audit calibration earlier. The model’s self-reported 0.9 is not always a true 90%. I did not spot the drift until the quote-check started leaking two false positives a week. For the broader frame on calibration, see why “70% sure” is more useful than “yes” and the sequencing advice in AI strategy for SMB owners.

If you are planning your first decision-model call inside a product you already ship, you can skip the mistakes I made by inverting the order on day one. Write the shape. Build the review queue. Audit calibration before you need to. The shape-first flip is not a technique; it is a habit, and habits are easier to install than to rip out.

Frequently asked questions

What does “I stopped asking my AI to write” mean in practice?

It means I stopped using a chat completion for the five places in my product where downstream code — not a reader — was consuming the AI’s output. For those call sites I now use a decision model that returns a typed value: a label, a number, or a probability. The chat model still writes the drafts, hover rewrites, and reader-facing explanations. The split is by who reads the answer, not by which model is smarter.

What is “the shape-first flip” that you coined in this piece?

It is my name for the mindset change behind the migration. Before: write the prompt first, then figure out how to parse the answer. After: declare the shape of the answer first — a label from this enum, a number on this scale, a probability on this statement — then write the prompt that fills that shape in. The reorder sounds minor and changes everything downstream, from testability to planning time.

How is this different from your companion piece about using Jev in your product?

The companion piece is the day-in-the-life tour of three decisions, with code shapes and thresholds. This piece is the conversion story — what changed in how I design AI calls when I stopped treating the AI’s output as prose. Different lens on the same migration. The companion coins “the deletion dividend” for what disappears; this one coins “the shape-first flip” for how I think about new calls.

Which five decisions did you move, and why those five?

Quote checks, metadata calls, section quality scores, priority ratings, and collection assignments. The common property is that none of them has a human reader — each one feeds downstream code (a routing rule, a sort, a filter, a shelf). That is the clean test I now apply before any AI call. If a function reads the answer, I use a decision model; if a human reads the answer, I keep the chat model.

Does the shape-first flip only work with TypeSafe AI’s Jev?

No. The three underlying shapes — Choose, Rate, Verify — map onto OpenAI’s Structured Outputs, Anthropic’s strict tool use, and Google Gemini’s responseSchema. The vendors differ on vocabulary and pricing; the pattern is identical. I use Jev because decisions are its only product; the mindset flip is the same whichever decision API you reach for.

What did I actually get back by making the flip?

Four concrete things: a shrunken parser folder, tests that are assertions on values instead of regexes over paragraphs, costs that stopped being a line item I watched, and planning hours I used to spend wordsmithing prompts. Speed improved too. The reclaimed planning time surprised me more than the latency did.

Should every AI call in my product be a decision call?

No. Apply the shape-first flip only where downstream code consumes the answer. If a human is going to read the output — a drafted email, a hover rewrite, a one-paragraph summary — keep a chat model and design for prose. The best AI products run both, with decision models under the hood for routing and scoring, and chat models on the surface for anything the user actually reads.

---

If you are planning the first decision-model call inside a product you already ship, that per-call-site judgment is exactly what a Fractional CTO is paid to help with. One hour on the shape, the review surface, and the calibration plan will save a quarter of engineering time. More pieces in this thread live in the AI Strategy archive.