Shaurya Mehta
JourneyShippedHow I workNotes
Get in touch
JourneyShippedHow I workNotes

How I work

I work with a fleet of coding agents, and I built the system they run in. An alert or an idea goes in. The agents review, push back on and test each other until the goal is met. Agents never ship; I do.

  • 30skills in my stack, one for each job
  • 18production alerts my triage agent worked through in its first week
  • 11business systems my MCP server opens to every session
  • 10knowledge bases in the one memory store every agent shares

A team of agents that checks its own work

Every bug and every feature runs as a multi-agent workflow. A lead agent hands each job to a fresh agent, so no agent marks its own work. The setup tests what it built, and goes around again until the goal is met.

  • A bug

    An alert lands in Slack

    My triage agent picks it up, reproduces it on real systems and posts the cause, the impact and a fix in the thread.

  • A feature

    An idea or a ticket

    Desktop and phone designs in Figma first, then the rules agreed in writing before any code.

  1. 01 · 3 reviewer agents

    Plan

    They attack the plan before code exists. Is it sound, does it do the job, does it fit the other plans?

  2. 02 · Implementer agents

    Build

    One per sub-feature, each in its own git worktree, so parallel agents never collide.

  3. 03 · A second model

    Review

    Codex reviews the whole change for defects and for drift from the plan.

  4. 04 · A fresh skeptic

    Push back

    Checks every finding against the code. What does not hold is rejected, with the evidence.

  5. 05 · Fixer agent

    Fix

    Fixes only what holds, with the smallest change and a test for it.

  6. 06 · Verify skills

    Validate

    Start the code on its own ports and databases, then drive it like a user in a real browser or API.

  7. 07 · Refinement loop

    Refine

    A check fails? Fix, rerun, check again. If it still cannot pass, it tells me why.

  8. 08 · Me

    I ship

    Agents stop at "fix ready". I read the evidence, then I push.

↺ Fix, validate, refine, again and again until the goal is met

  • apex-memory every step reads the decisions and writes down what it learned
  • My MCP server every step can see errors, logs, databases, analytics and sales
  • S3 Code every session sits under a task on one board

The tools I built for it

Agents forget, collide and guess. Each of these fixes one of those.

  • Triage agent

    Alerts answered before I open Slack

    Sentry posts error, crash and slow-page alerts to Slack. Twice a day my agent reads them and opens one Claude session per alert. Each session reproduces the error through my MCP server: errors, logs, both databases and analytics. It replies in the alert's thread with the cause, who it hit, how sure it is and the fix, and tracks the alert in a sheet until it ships. When I say go, it fixes it on its own branch and runs the review and end-to-end checks.

    18 alerts in the first week, each with a cause and a proposed fix

    Slack, Sentry, Google Sheets, Claude sessions on a schedule

  • MCP server

    Every session sees the business

    The server I built for the founder is also every agent's window into the business. Triage reads errors and logs through it. Feature sessions check real figures and test changes against it.

    12 tools over 11 systems

    sales, catalogue, ads, analytics, errors and logs

    Case study →
  • S3 Code

    My own build of T3 Code

    The desktop app every session runs in, forked and extended. I built a task list into it, one level above sessions. Agents link their session to a task, keep its status true and suggest new tasks, so work survives a closed terminal. Tasks get folders and colours, a session reopens its task when you talk to it again, and a release pipeline builds and signs the macOS app with an installer.

    28 commits on my fork

    tasks, sidebar, release pipeline

    See the fork ↗
  • Memory

    apex-memory

    One knowledge store that Claude Code and Codex share. Every decision has one page that owns it, so the next session reads the decision instead of guessing it again.

    49 tool calls instead of 141

    the same 7 tasks, with and without it

    Case study →
  • Verification

    A verify skill for every repo

    Each repo has a skill that starts it from any worktree on its own ports, with its own databases and seeded sign-ins, drives it like a user would and saves before-and-after evidence. An agent proves a fix on the same path the bug took.

    4 repos, each provable from any branch

    backend, services, website and CMS

  • Alerts

    Alerts that mean something

    The slow-page alert used to average every browser span. I rebuilt it to watch what visitors feel, the largest paint on product pages. I set up CloudWatch logging for the services, and an hourly memory log caught the leak that crashed the store.

    0 restarts after the leak fix

    memory flat near 533 MB, against 1,146 MB before

My skill stack

A skill is a written procedure an agent loads for one job. I keep one for each job, so a session never improvises how to plan, test or review.

  • Plan

    Attack a plan, or a whole set of plans, for gaps before anyone builds.

  • Backend

    Take a feature from agreed rules to tested branches, one sub-feature at a time, then check the branches fit together.

  • Verify

    A verify skill for each repo starts it from any worktree on its own ports and databases. The end-to-end skills drive it like a user.

  • Review

    Hunt defects, check the change against its plan, then fix only what holds.

  • Frontend

    Distinctive interfaces, a design system and a review rubric.

  • Motion graphics

    Animated explainers and interface motion.

  • Image generation

    Images made to an art direction, like the paintings on this site.

  • Writing

    Docs in Simplified Technical English, explanations top down, and posts.

What the agents can reach

Each one is an MCP server, so any session can use it.

  • My MCP serverThe business itself, read and change, with a preview before every change
  • apex-memoryThe decisions, contracts and findings of every project
  • Chrome DevToolsLighthouse audits, performance traces and network logs, headless
  • PlaywrightReal browsers for end-to-end tests
  • FigmaThe designs, read before code and written from it
  • SentryErrors, traces, replays and the alert rules
  • SlackAlert threads in, findings out
  • ClickUpThe tickets the work comes from

Rules every session follows

  1. Design before code

    Screens approved in Figma first. Where the design is silent, the agent asks.

  2. Nothing is done until it ran

    Every feature runs end to end on real systems, never production, before anyone calls it done.

  3. One review per sub-feature

    One review of the whole change by a second model, never per task, and every finding is checked first.

  4. Only I ship

    No agent pushes, merges or deploys. They hand me the branch and the evidence.


Building something with AI agents?

Email me

Designed and built by Shaurya Mehta

  • GitHub
  • LinkedIn
  • X
  • LeetCode
Not written yet