Dev Notes
Dev Notes: April 17, 2026
Most engineers treat AI output as a single answer. Prompt, read, copy, move on. When something's off, they rewrite the prompt from scratch or patch the code by hand and call it a day.
That's the gap I see at work every week. The tools are there. The intelligence is there. What's missing is iterating with the agent. Pushing back. Asking why it made a choice. Rewinding when a branch goes bad. Capturing what you edited so the next run does it right the first time.
Two skills I've been building at work force the loop. /reflect runs when a session feels off, scans the transcript for where things went sideways, and routes the fix to the right layer (a rule, a skill, a CLAUDE.md, or a global config). /voice handles short-form writing (PR comments, Jira replies) by drafting into a temp file, letting me edit it in my editor, then diffing my edits back into a global voice.md. Every post teaches it something.
Neither is clever. They just make the iteration visible so you stop ignoring it. The real skill with AI is closing the loop. The engineers getting the most out of these tools iterate fast and keep what they learn from each pass.
This Week on Slightly Caffeinated
E56: Reflection Skill, PRDs, and Self-Improving Workflows
TJ and I walk through the two skills I've been building (/reflect and /voice), how his PRD generation skill forces a real problem statement before any code gets written, and his new per-task review loop in Chief that double-processes every task before it's marked done. Plus: his first run with Gent on thread forking in Iris, and Karpathy's LLM Wiki pattern as a self-organizing PKM.
New episode drops tomorrow (Saturday) at 8:30am Eastern.
What I'm Learning
I've been over prompting my corrections when I should have been using /rewind.
An Anthropic PMM shared a breakdown of Claude Code session management this week that reframed how I think about every turn. The move I was missing: when an action goes wrong, double-tap Esc to jump back to the last good point and re-prompt with what you just learned. Don't continue the session and type "that didn't work." That leaves the failed attempt in context and biases the next turn.
Rewind drops the bad branch entirely. You keep the setup work (file reads, exploration) and replace the bad decision with a better one. Tried it on three sessions this week. Output quality jumped. Less churn, cleaner commits.
Same idea applies to proactive /compact before pivots. The model is at its least sharp during auto-compact (context rot peaks right when it needs to summarize), so steering the compaction yourself is the safer move.
Links Worth Your Time
Claude Code Session and Context Management - Anthropic PMM on the five options you have at every turn: continue, rewind, clear, compact, or subagent. The best single piece I've read on working with the 1M context window without drowning in it.
Karpathy's LLM Wiki - Andrej Karpathy's thesis on using an LLM to maintain a self-organizing wiki. TJ pinned this into Iris and started feeding it URLs, YouTube videos, and research notes. The self-organization held up better than expected.
Dev Tool of the Week
David Hemphill's new Ralph-looping agentic coding app. TJ used it this week to ship thread forking in Iris. First Ralph loop app I've seen where the UI actually helps you understand what the agent is doing.
Feed it a PRD. Gent extracts tasks, maps dependencies, and parallelizes the work. The Kanban board shows tickets moving through backlog, in-progress, and review with animated dependency arrows. Configurable review gates (ESLint, Larastan, Pint) must pass before a task is marked complete.
The standout: it surfaces PRD gaps during code review. Bad PRD, bad output, visible right away. That tight feedback loop makes quality control with autonomous coding agents a lot more tractable.
Trying it on a side project this weekend.
That's it for this week. Hit reply if you've been using rewind, or if you're still typing "that didn't work, try again." I want to hear what your session habits look like.
– Chris