AI Workflow Principles

These principles were principles that Aaron Dignan and I promoted at Plumb, but it was largely based on my experience of building for AI.

These are as much my build principles as they were our companies.

1. Start Small Start with a basic, functional workflow and gradually add complexity and intelligence, ensuring it always works at a foundational level.
2. Break It Down Break AI steps into smaller, manageable units to reduce cognitive load, improve reliability, and maintain cost efficiency without increasing token usage.
3. Agentic Where It Matters Use AI only where it provides clear value, and prefer deterministic logic elsewhere. Define tasks clearly to reduce uncertainty.
4. When In Doubt, Structure Out When possible define the output schema of every AI step to ensure quality and precision downstream.
5. Get Abstract Build with abstraction in mind: hoist user-specific details out of prompts and into clearly defined variables. This enables scalable, reusable workflows while still supporting deep personalization.
6. Right Model, Right Job Select AI models at the step level based on specific task requirements. Choose the most appropriate model for each operation to optimize for speed, cost, and effectiveness rather than standardizing on a single model.
7. Reduce Risk Match the automation strategy to the consequence of failure: fully automate low-risk tasks and maintain human-in-the-loop for high-risk tasks.
8. Know Your Ins & Outs Don't start building until you can clearly articulate the persona you are building for, and what your inputs and outputs look like.
9. Modularity Scales Think about the sub-flows in your builds as compositions, designed for re-use, and optimize them accordingly.
10. Problem First Don't start with a solution or technology in mind ("We need a chat connected to a RAG"), start with the problem and determine the best way to solve it.
11. The Best UI is No UI Expert automations should feel like a seamless part of users' existing tools and habits, minimizing added interfaces and friction. Only create a surface when that's the preferred user experience.

Start Stupidly Small

Here's what I learned the hard way: the fancier your first version, the harder it is to debug when things go wrong. Start with the dumbest possible workflow that accomplishes the core task, even if it feels embarrassingly simple. Once you have that baseline working reliably, you can layer in the intelligence and complexity. Think of it like building with Lego: you need a solid foundation before you start adding the turrets and dragon wings.

Break It Down

Every time I've hit a wall with an AI workflow, it's because I tried to do too much in a single step. Breaking AI operations into smaller, discrete units does three magical things at once: it makes each piece easier to reason about, it improves reliability (smaller tasks mean clearer instructions), and it keeps costs manageable without burning extra tokens. The secret is that multiple focused steps often perform better than one mega-prompt trying to juggle everything.

Agentic Where It Matters

Not every step in your workflow needs AI, and that's actually great news. Use deterministic logic (good old if-then statements, string manipulation, API calls) wherever you can, and save the AI for tasks that genuinely need reasoning or creativity. When you do use AI, be ruthlessly specific about what you're asking it to do. Vague tasks produce vague results.

When In Doubt, Structure Out

The fastest way to turn chaos into consistency is to define exactly what shape you want your AI's output to take. Give every AI step a clear schema (JSON works beautifully for this) so downstream processes know exactly what they're getting. This is like building with LEGO bricks that click together perfectly instead of trying to glue random shapes and hoping they stick.

Get Abstract

Stop hardcoding user details directly into your prompts. Instead, build workflows that pull personalized data from variables, making your system reusable across thousands of users without rebuilding everything. Think of it like writing a form letter: you want the structure to be fixed, but the name, address, and details should be swappable. This approach lets you scale while maintaining that personal touch.

Right Model, Right Job

Here's the thing: GPT-4 is overkill for summarizing a bullet list, and a tiny model will butcher complex reasoning. Pick your models at the step level based on what each task actually needs. Use the fast, cheap model for simple classification, bring out the big guns for nuanced analysis, and watch your costs drop while performance goes up. It's like using a sledgehammer for demo work and a finishing hammer for trim carpentry.

Reduce Risk

Match your automation level to what happens if things go sideways. Sending a welcome email? Fully automate that. Approving a $50,000 refund? Keep a human in the loop. The key is identifying which failures are "oops, let me resend that" and which are "oh no, we just angered our best customer." Build guardrails accordingly.

Know Your Ins & Outs

Before you write a single line of workflow code, answer these questions: Who is this for? What information are they giving me? What do they need back? If you can't clearly articulate your inputs, outputs, and target persona, you're building in the dark. This clarity is like having a destination in your GPS before you start driving.

Modularity Scales

Build your workflows like composable functions, not monolithic scripts. When you create a sub-flow that extracts key points from text or formats data in a specific way, design it so you can drop it into other workflows without modification. Future you (and your teammates) will thank you when you can reuse battle-tested components instead of rebuilding from scratch.

Problem First

I've watched teams spend weeks building a RAG-powered chatbot before realizing their users just needed a better search filter. Start with the problem you're solving, not the cool technology you want to use. Sometimes the best solution is a well-organized spreadsheet, not an AI agent. Let the problem dictate the tools, not the other way around.

The Best UI is No UI

The most powerful automations disappear into people's existing workflows. If you can solve the problem inside Slack, email, or whatever tool people already live in, do that instead of building a separate dashboard they need to remember to check. Only create a new interface when the task genuinely demands it. The best automation is the one users don't even realize they're using.