The Workflow Wrench

AI research and AI application are different jobs. Most clients pay for the second: turning messy work into repeatable workflows.

• The daily work is interviewing users, wiring APIs, tuning prompts, handling edge cases, and maintaining the system.
• The durable skill stack is APIs, JSON, webhooks, just-enough Python, databases, workflow logic, prompting, n8n, agents/MCPs, and process interviewing.
• Small and mid-size businesses still have plenty of manual CRM, invoice, meeting, and lead-response work.

Every paying job is a translation problem. Sort the user's story into trigger, inputs, decision, action, and observation.

• A bookkeeper receipt flow becomes email trigger, body/PDF inputs, category decision, sheet append action, and row-count observation.
• Reliability means handling failures, bad inputs, repeats, drift, and silence.
• The one-page spec answers replacement value, happy path, unhappy paths, and success metrics.

Good candidates are recurring, structured, annoying, cheap to fail, and accessible through systems you can call.

• Use 30 minutes per week as a rough time-savings floor, while counting context-switching pain when it is real.
• High-stakes work can still be useful, but automate preparation and keep the final decision human.
• Score ideas 0-3 across frequency, structure, irritation, failure cost, and data access. Under 7 is weak; 9+ is a strong candidate.

Most stalls come from tutorial loops, hype chasing, premature scaling, perfectionism, and toolchain addiction.

• Follow input with output in the same sitting.
• Pick n8n, one LLM, and Python for 90 days before shopping alternatives.
• Your first ten projects should be services, not products.
• Name unhandled edge cases and ship the version that works enough to test.

An API is a request/response contract. Most automation work means reading docs, sending HTTP, handling auth, and parsing JSON.

• Requests have method, URL, headers, and optional body.
• Responses have status code, headers, and body. Know 2xx, 4xx, 5xx, and especially 401 vs. 403.
• Use bearer tokens or OAuth, respect rate limits, and avoid loops that hammer APIs.

JSON is structured text with six types: string, number, boolean, null, array, and object.

• Most work is navigation: find the value inside nested arrays and objects.
• Dots step into objects; brackets step into arrays.
• Watch trailing commas, comments, and the difference between null and missing.

A webhook is a URL you give a service so it can POST to you when something happens.

• Use webhooks when available; poll only when you must.
• Develop with workflow tools, webhook.site, RequestBin, ngrok, tunnels, or cloud functions.
• Verify signatures when needed and design handlers to be idempotent because providers retry.

You need enough Python to read JSON, call APIs, branch, write files or databases, and handle errors.

• Use virtual environments, requests, environment variables, small functions, and explicit exceptions.
• Write JSON and CSV with the standard library.
• Use pagination and retry with backoff for real APIs.

A database stores data between workflow runs. Start with Postgres for business data, SQLite for tiny solo work.

• CRUD maps to SQL: INSERT, SELECT, UPDATE, DELETE.
• Joins connect related rows. Aggregates answer questions over groups.
• Use parameterized queries. Never concatenate user input into SQL.

A demo runs once. A workflow runs repeatedly, handles ugly inputs, and tells you when it breaks.

• Choose triggers: schedule, webhook, polling, or manual.
• Always include an unknown branch and keep branches mutually exclusive.
• Add idempotency, retry with jitter, dead-letter queues, logs, and healthchecks.

A workflow prompt is usually split into stable system instructions and variable user content.

• Control persona, task, constraints, examples, temperature, max tokens, and stop sequences.
• Specific verbs beat vague help requests.
• Low temperature fits extraction and classification; higher temperature fits drafts.

The reliable patterns are role plus task, few-shot examples, stepwise reasoning when judgment is needed, structured output, and delimited input.

• Examples should mirror real production variations, including edge cases.
• Use delimiters so user-supplied text is treated as data, not instructions.
• Ignore magic phrase folklore. Test against the model you actually use.

Free text is brittle when another step has to consume it. Use structured output, define a schema, validate, and retry once on failure.

• Fields need names, types, and allowed values.
• Native JSON or structured-output modes beat "please format nicely."
• Log raw failed output so you can see what broke parsing.

Reusable prompt functions keep the same classifier, summarizer, and reply drafter available across projects.

• Create typed outputs with Pydantic or equivalent validation.
• Use one helper to call the model, then one function per prompt pattern.
• Start with email classification, meeting summary, and reply drafting.

n8n is open-source, self-hostable, visible, and has a code escape hatch. That combination makes it useful even if a client later prefers another tool.

• Learn n8n deeply; know Zapier and Make enough for client constraints.
• Move to cloud functions or agentic coding when the canvas becomes the constraint.

Start with n8n Cloud for speed or Docker for free self-hosting. Learn workflow, node, trigger, action, item, expression, and credential.

• Every node has parameters, input JSON, and output JSON.
• Expressions in {{ }} reference current or upstream values.
• Build in Test mode; switch to Active when shipping.

Schedule a daily run, read RSS, filter items newer than 24 hours, format a digest, and send by email or Slack.

Receive a form webhook, append name/email/topic to Google Sheets, and send a confirmation email.

Watch an inbox, classify email as buyer/applicant/partner/spam/other, parse JSON, and route each category to the right place.

Take a lead, derive the email domain, call enrichment APIs, score fit with an LLM, and branch into auto-reply, sales routing, or human review.

The model sees a goal, chooses a tool, receives the result, and repeats until done or bounded.

• Most paid work still fits one LLM step in a deterministic workflow.
• Use tool-using agents when the steps are unknown in advance.
• Bound loops, limit tools, validate calls, require approval for dangerous actions, and log each step.

Claude Code, Codex, Cursor, Aider, Continue, and Cline show what an agent loop looks like in a domain where it already works well.

• Give project context through instructions files.
• Assign small, well-scoped tasks.
• Review diffs and run tests. The assistant is fast, not infallible.

Model Context Protocol standardizes tools, resources, and prompts that AI clients can discover and call.

• Useful servers include filesystem, GitHub/GitLab, Slack/email, databases, browsers, and internal tools.
• MCP servers run on your machine or infrastructure. Vet code and limit credential scope.

The model only knows what is in the current context. Memory systems choose what to put back.

• Short-term memory keeps recent turns and trims old ones.
• Long-term facts can live in a key-value table.
• Episodic memory uses RAG: chunk, embed, retrieve, inject, answer from context.

Use supervisor/worker, pipeline, or critique topologies only when specialization or criticism clearly helps.

• If one structured prompt works, use one structured prompt.
• Each handoff can compound error; validate and keep chains short.

Realtime voice agents can handle tight domains: reception, lead qualification, appointment scheduling, and simple orders.

• The stack is telephony, speech-to-text, LLM brain, and text-to-speech.
• Latency, interruptions, accents, and human failover decide trust.
• A first paid version can collect caller info, schedule a callback, and text the owner a summary.

New leads should reach the right owner within 60 seconds. Classify, enrich, assign, notify, log, and draft a reply.

• Success target: 95% assigned within 2 minutes and under 5% weekly misroutes.
• Setup baseline: $1,500-3,500; care: $150-300/month.
• Never auto-send the first reply. Draft it and let the salesperson send.

Watch client email and calendar activity, summarize interactions, match to CRM contacts/deals, and update after human approval.

• Success target: 80%+ meaningful interactions logged automatically and 90%+ rep approval.
• Setup baseline: $3,500-7,500; care: $400-800/month per seat.
• Email access needs explicit consent, opt-out, and careful data retention.

Use meeting transcripts to create summaries, decisions, owner/date action items, tracker tasks, and Slack posts.

• Add a Friday digest grouped by owner for unfinished commitments.
• Setup baseline: $2,500-5,000; care: $200-500/month.
• Require concrete verbs, deliverables, and due dates. Vague action items go nowhere beautifully.

Build a first-line responder that answers from an FAQ, captures structured info, books appointments, and escalates when outside scope.

• Success target: 60%+ conversations resolved without human intervention and zero invented facts.
• Setup baseline: $3,000-6,000; care: $400-1,000/month plus conversation costs.
• Identify as a bot, ask one question at a time, offer a human, and never argue.

Extract invoices, receipts, contracts, and forms into structured data, validate, then store or queue for review.

• Success target: 95%+ field-level accuracy and clear low-confidence review.
• Setup baseline: $4,000-10,000; monthly or per-document pricing often $0.10-0.50/document.
• Guard against swapped fields with explicit schema descriptions and sanity checks.

Use setup fee, care retainer, and hourly new-work rate. Quote outcomes, not typing time.

• Setup baseline across projects: $1,500-15,000.
• Care baseline: $200-1,500/month for hosting, monitoring, and small changes.
• New work: $120-250/hour starting, raised yearly.

Start with warm intros, free pilots for accessible businesses, narrow LinkedIn outreach, niche communities, and job boards only when cashflow needs it.

• Be specific: lead routing, CRM updates, document processing, meeting summaries.
• Free pilots should be one week, one automation, and tied to a case study and paid continuation offer.
• Twenty researched messages beat a cold blast.

A 30-minute call should end with a spec and next step, not a premature technical proposal.

1. Ask them to walk through their week.
2. Ask which task ruins a day.
3. Ask what changes if that task disappears.
4. Ask them to show the current process on screen.

Keep definitions short enough to use mid-build: agent, API, auth, backoff, branch, CRUD, chunk, context window, credential, curl, dead-letter queue, embedding, endpoint, few-shot, function calling, HMAC, HTTP, idempotent, JSON, JSONB, jq, LLM, MCP, n8n, OAuth, OCR, pagination, polling, prompt, prompt injection, RAG, rate limit, REST, retry, schema, SDK, SQL, structured output, system prompt, temperature, token, tool use, trigger, vector database, webhook.

The reusable sheets are a one-page spec, proposal one-pager, prompt skeleton, pre-ship checklist, HTTP status table, and Python snippets for API calls, env secrets, retries, and validation.

The PDF recommends official docs and durable books over tool-chasing. Bookmark Anthropic docs, OpenAI Cookbook, n8n docs, Postgres docs, and MDN. Read Designing Data-Intensive Applications, The Pragmatic Programmer, and Atomic Habits slowly.

Useful communities include n8n Community Forum, Indie Hackers, and local or industry-specific business groups. Newsletters are for skimming: Ben's Bites, Latent Space, and The Pragmatic Engineer.