One note a day. Read in five minutes, use the same day.
Thirty days of practical notes while the channel launches — from prompting to agents, skills, verification, MCP and production. New note every morning at 07:30 GMT. Examples mostly use Claude Code; the patterns apply to Cursor, Codex, Copilot and any agent that edits your repo.
Is AI actually helping your team?
Perceived speed is unreliable; baseline lead time, review time, defect escape rate, and rework rate before rollout, then compare, not guess.
Automate one weekly task end to end: a worked example
Pick one recurring task, build it as a pipeline with two verification points, and measure the time it actually saves before trusting it.
Agents that browse and pay: what changes for builders
Agent-specific browser runtimes and the x402 payment protocol let an agent complete a purchase itself — decide up front where a human still has to approve.
Multi-agent patterns that converge (and ones that don't)
Fan-out into a verify gate and a synthesis node converges; two agents revising each other with no stop rule loops forever.
Audit trails for agent actions
Log every tool call, diff, and approval as it happens so an agent session is reviewable later without replaying or trusting memory.
Secrets and agents: what should never reach the prompt
Keep credentials out of prompts and CLAUDE.md; inject short-lived scoped tokens at runtime and deny the agent read access to secret files.
MCP security: tool poisoning and prompt injection
A tool's description and its results reach the model as plain text — validate both, or an untrusted server can quietly redirect an agent's actions.
Build a minimal MCP server in Python
Wrap one existing FastAPI endpoint as an MCP tool in about ten lines using the current mcp package, then register it with claude mcp add.
MCP in plain English
MCP is one protocol so a tool you build once works from Claude Code, Cursor, and Codex without three separate integrations.
Keep a mistake log
Every agent failure should become a CLAUDE.md line, a hook, or a test — the classification decides which, and none of the three is optional forever.
What an agent should never be allowed to do
Sort agent actions into always, ask, and never rings by blast radius, not by how often they happen — and contain the rest in a sandbox.
Reading the bill: the economics of one agent task
One hour of Claude Opus 5 agent work on the same tokens runs $0.71 uncached or $0.53 cached — caching shrinks the input line, not the output.
Bounded autonomy: loops with stop criteria
A run-until-green loop needs three exits, not one — done, out of budget, and out of iterations — or it will eventually run past all three unnoticed.
The strict reviewer: a prompt that finds real issues
A code-review prompt that asks for severity, a failing input, and a fix produces findings you can act on; one that asks for feedback produces compliments.
Tests an agent cannot game
An agent under pressure to go green will edit the test before it fixes the bug unless the test is built so that editing it doesn't help.
Verification is the bottleneck, not generation
Agents made writing code fast; they didn't make checking it fast, so that's where your time and process now need to go.
Onboard the agent like a senior hire
The questions you'd answer for a new engineer on day one map directly to files an agent reads — write them down once instead of repeating them in every prompt.
Why long agent sessions degrade, and what to do about it
Context doesn't get smarter as it fills up: stale output crowds out live instructions, so split tasks and reset sessions instead of pushing through.
Sharing and versioning skills across repos
Skills live at personal, project, or enterprise level; share them across repos with a plugin marketplace, pin versions, and review changes like code.
Five skills every backend team should have by Friday
Five short SKILL.md files — review, test, explain, release, migrate — cover most of a backend team's recurring judgment calls.
Prompt, skill, hook, or MCP server?
Match the mechanism to the need: one-off gets a prompt, repeatable judgment gets a skill, must-always-happen gets a hook, external access gets MCP.
Anatomy of a SKILL.md
A SKILL.md is two required fields, a body of procedural instructions, and optional files loaded only when the agent actually needs them.
Prompts are disposable. Skills compound.
A prompt in chat history dies with the conversation; a skill saved to the repo gets better every time someone edits it.
How to read an agentic benchmark
Chat benchmarks score one answer; agentic benchmarks score a whole trajectory of tool calls and recoveries — read them differently.
Which model for which job: a routing rule that cuts the bill
Route by task shape, not habit: cheap-tier for mechanical work, daily-tier for most coding, frontier-tier only for hard judgment calls.
One does, one checks: subagents as a reviewer
Give a second, fresh-context agent only the diff and a checklist — it catches what the builder agent is too invested to see.
Fix the root cause, not the test: a definition of done
"Make the tests pass" and "fix the bug" are different instructions — write stop criteria that make the difference explicit.
Hooks: verification as a loop, not a step
A PostToolUse hook that runs tests after every edit turns verification into something that happens automatically, not something you remember to ask for.
Write a CLAUDE.md the agent actually uses
Put in what code can't say — commands, done criteria, and never-do rules. Leave out anything the agent can read for itself.
What an AI agent actually is (and what it isn't)
An agent is chat plus three properties: it knows your project, checks its own work, and keeps going without you.