Featured

Your open-source repo has four hundred stale issues, no labels, and no routing.

Featured

You listen to a 20-minute meeting recording and manually write down action items, missing half of them.

Featured

Your agent's retrieval returns ten loosely relevant chunks because pure semantic search can't tell which belong to which user or which date range.

Featured

Your agents talk to each other through nested function calls.

Featured

You have one generic agent handling researcher, writer, and editor roles, and the output reads like all three are fighting for the keyboard.

Featured

You tried to chain four agents together and the output of each one contaminated the input of the next until the final...

Read tutorial→operational

The Builder Weekly

Tutorials · Archive

Agent-building patterns

Every entry teaches one task where an AI agent measurably beats a human. Before-state, after-state, and one sentence naming exactly why the agent wins.

Propose a tutorial on GitHub →Read the merge gate →

Accountability

(2)

Proving agent work actually happened. Scheduling, verifying, and auditing agent outputs so you know the work was done, not just claimed.

Verify every scheduled job actually ran
An agent can check a hundred cron outcomes per second against expected state, which a human doing daily ops review does in thirty minutes and misses silently.
Read →
Build an accountability loop for your AI agent
An agent can verify its own work at machine speed across hundreds of tasks simultaneously, which no human can do without a dashboard and hours of spot-checking.
Read →

Memory

(3)

Persistent state across sessions. Writing, retrieving, and scoping agent memory so the agent gets better with every interaction.

Retrieve from a vector store with metadata filters and get the right chunk
An agent combining semantic search with metadata filters reaches into ten million chunks and returns the right one in under a hundred milliseconds, which a human searching a SQL database by hand cannot come close to matching.
Read →
Scope agent memory per user without leaking across sessions
An agent can index and retrieve against millions of per-user memory stores in parallel, which a human operating the same product would need a team and a custom dashboard to match.
Read →
Give your agent memory that survives a restart
An agent with persistent memory improves its responses over time without retraining, which a human doing the same job would need a notebook and perfect recall to match.
Read →

Visibility

(2)

Making agent-built sites visible to crawlers. Exposing content so AI crawlers and retrieval systems can actually read it.

Generate dynamic OG images so your content gets clicked when shared
An agent generates a unique OG image per page in milliseconds, which a human designing them by hand would need a graphic design tool and an hour per piece.
Read →
Ship an llms.txt that tells agents what your site is
An agent that reads a well-structured llms.txt picks up your entire corpus in one pass, which a human writing documentation by hand would take months to make this legible.
Read →

Agent Teams

(5)

Running coordinated multi-agent systems. Composing specialized agents into a workflow with typed handoffs that survive production.

Wire agents together with a message bus instead of function calls
A message-bus-coordinated agent system handles stage failures, retries, and back-pressure correctly on every single run, where a human wiring the same coordination by hand would cut corners on the retry logic and regret it in production.
Read →
Author role-specific system prompts that actually change behavior
An agent with a well-scoped role-specific system prompt produces deterministically specialized output on every call, where a human generalist switching between roles loses context and degrades over the day.
Read →
Run a roster of four agents in a single workflow without the wheels coming off
An agent team with well-defined handoffs produces the same multi-step result end-to-end in one minute that a four-person human team takes a full meeting to coordinate, and the agent team doesn't need a meeting.
Read →
Build a research agent team where one agent finds, one verifies, one summarizes
Three specialized agents working in sequence produce verified research in five minutes; one generalist agent doing all three jobs takes twenty minutes and produces ungrounded claims.
Read →
Route customer queries to specialized agents based on intent classification
A router that dispatches to five specialists handles a thousand customer queries per hour with consistent expertise per category, which a single generalist agent handles slower and worse.
Read →

Scoping

(2)

Killing bad ideas before building. Using agents to critique, stress-test, and triage ideas so you do not ship the wrong thing.

Constrain agent tool access with per-task allowlists
An agent with fifty tools available picks the wrong one twelve percent of the time; an agent with five tools scoped to its current task picks correctly ninety-nine percent of the time.
Read →
Force structured agent output with JSON schema validation and retry
An agent with strict schema validation retries until it produces valid output, which a human reviewing free-form output would catch by reading every response and re-prompting manually.
Read →

Operational

(4)

Task-specific entries that do not fit a single pillar. Competitor pricing watch, issue triage, RSS filtering, and other one-shot utilities.

Triage a GitHub issue backlog overnight
An agent reads, classifies, and labels a thousand issues per hour with deterministic rules, which a human maintainer gets through maybe thirty before burning out.
Read →
Turn a voice note into structured tasks in 30 seconds
An agent processes audio at 40x real-time speed with consistent extraction recall, which a human transcriber cannot match without multiple listens.
Read →
Generate images from your AI agent without burning a hundred dollars on bad outputs
A naive image generation agent produces 100 mediocre images at $5 total cost; a properly-prompted agent with output verification produces 10 great images at the same cost.
Read →
Filter a hundred RSS feeds into a daily brief worth reading
An agent applies a consistent editorial filter to thousands of items per day, which a human trying to maintain the same signal-to-noise ratio would spend two hours on and still miss things.
Read →

Payments

(2)

Patterns for agents handling money. Charges, subscriptions, refunds, payouts. Idempotency, webhook verification, and the failure modes that matter when dollars are at stake.

Meter agent usage and bill customers in real-time without manual reconciliation
An agent meters a thousand customer API calls per second with sub-cent precision, which a manual usage report at month-end gets wrong by five to fifteen percent and creates billing disputes that erode trust.
Read →
Process payments from your AI agent without losing money to retries
An agent retrying a charge without idempotency keys has charged the same customer 47 times before a human noticed; with proper idempotency the same agent can safely retry indefinitely.
Read →

Foundations

(3)

What every production agent needs underneath it. Observability, budget enforcement, retry logic, error handling, the stack you would otherwise reinvent for every project.

Build multi-step AI agent workflows with human approval at the right moments
An autonomous agent doing a 10-step task fully autonomously will eventually take a wrong path costing real money or trust; a state-machine agent with approval gates at the right steps gets the same speed with bounded risk.
Read →
Stop your AI agent from running up a thousand-dollar bill overnight
An agent looping on a malformed input can burn through a month's API budget in 20 minutes; a budget-enforced agent stops itself before the bill arrives.
Read →
The observability stack every production AI agent needs
An agent without observability is a black box; an agent with structured logs, traces, and per-step latency metrics tells you exactly where it failed and why, before the user noticed.
Read →

Communication

(2)

Patterns for agents that interact with humans through messages. Email, chat, notifications. Reading inboxes, drafting responses, gating sends through human approval.

Send context-aware Slack notifications that get noticed instead of muted
An agent that calibrates notification urgency per event reaches the right person at the right time with eighty percent lower mute rate than a fixed-rule notification system.
Read →
Build an AI agent that triages your inbox without sending anything embarrassing
A human triages 200 emails in 90 minutes with declining accuracy as fatigue sets in; an agent triages 200 emails in 30 seconds with consistent classification and gates every send through human review.
Read →