Maddy Zhang walks through her daily workflow with coding agents, models that edit code and run tools. The nine-minute video follows a task from project setup to human review. Her emphasis is on giving agents durable instructions, catching design mistakes early and asking for evidence before accepting a change.

Turn repeated corrections into project instructions (01:18)

  • A fresh session has no memory of the conventions explained in an earlier conversation. Zhang describes repeatedly correcting the same plausible-looking mistakes before moving those lessons into files the agent reads automatically.
  • Put general preferences in a global instruction file. Keep repository-specific rules in a local file such as CLAUDE.md or AGENTS.md. When an agent chooses the wrong library or component style, record the underlying rule.
  • Keep occasional procedures in skills, reusable task-specific instructions loaded when needed. A detailed migration, release or debugging procedure adds noise when every unrelated session has to read it.

Review the design before generating code (02:55)

  • Zhang uses a planning mode that reads the project and proposes an approach before editing files. She treats its output like a design document.
  • Question the choices that would be expensive to reverse: database assumptions, file layout, naming, reused helpers and integration with existing code. Ask how the design behaves as the number of users grows.
  • Requirements often originate in meetings. Capture the decisions and reasons before asking an agent to implement them. Otherwise, even a careful plan can start from an incomplete reconstruction of the conversation.

Separate branches and agent contexts (05:25)

  • Zhang works mainly in the terminal with Claude Code and Codex. A terminal multiplexer such as tmux lets her resume the same working session after disconnecting.
  • Git worktrees provide separate directories for different branches while sharing repository history. She can handle a quick fix without stashing an unfinished feature or making a temporary commit.
  • Subagents work on delegated tasks in separate contexts, with a lead agent assigning work and collecting results. Separate contexts keep individual assignments focused; worktrees give separate branches their own working directories.

Give autonomous work a test and a finish line (06:41)

  • Zhang calls the write–test–fix cycle loop engineering. Supply a task, a way to check the result and a clear definition of done. The agent can then repeat the cycle without waiting for a correction after every attempt.
  • Her example is getting a whole test suite passing. The agent writes an attempt, runs tests, reads failures and fixes them until it reaches the stated finish line.
  • Graph engineering connects several loops. Research, implementation and review can each have their own clean context while contributing to the same task.

Review according to the damage a mistake could cause (07:36)

  • Low impact: for copy, a log line or a test-only change, Zhang reads the summary and glances at the diff.
  • Ordinary feature: skim the code and require an end-to-end demonstration. Screenshots, recordings or actual output should show the feature exercised as a user would use it. She often tests it herself too.
  • High impact: read every line for changes involving payments, authentication, permissions, sensitive data or database structure. Test manually and use a feature flag so behavior can be checked in staging before production.

Caveat: this is Zhang’s personal workflow, without measured productivity or reliability results; the video includes a Granola sponsorship.