Prakash Upadhyay

How I build

Agents do the work. I make the calls.

I build my products, tools and content with AI agents: mostly Claude, in Claude Code on my machine and through the Claude API inside apps, with other tools when a task needs them. This is the loop I follow, and the points where I stay in charge.

ResearchSpecDesignBuildReviewShipShareReuseHumanin the loop
  • Agents
  • Human

One loop, eight stages, four gates.

Agents do the work at every stage: they research, draft, design, code, check and package. The loop only moves past a gate when I've looked at the result and said yes.

Reuse closes the loop: anything I do twice becomes a skill or a plugin, and the next project starts faster.

Stage by stage

  1. 01

    Research

    Human gate

    Agents do

    Gather sources, competitors and prior work, and summarise what they found.

    I decide

    Whether the idea is worth building at all.

    Tools

    Claude · web research · artifacts

    Example

    "Taking On BookMyShow: Research & Validation Plan" [private, share to link]

  2. 02

    Spec

    Human gate

    Agents do

    Turn my notes into a spec: scope, edge cases, acceptance criteria.

    I decide

    Approve the spec before any code is written.

    Tools

    Claude · Markdown specs

    Example

    "CertPulse Product Decisions Log" [private, share to link]

  3. 03

    Design

    Agents do

    Explore page and app layouts, then build design systems and canvases.

    I decide

    Pick the direction and cut what doesn’t belong.

    Tools

    Claude design canvases · design systems

    Example

    This site: mock-up, design system and icons, made with Claude.

  4. 04

    Build

    Agents do

    Write code and tests in my repos, inside the constraints I set.

    I decide

    Architecture, boundaries and what the agent may touch.

    Tools

    Claude Code · Claude API

    Example

    CertPulse, and "From idea to v1: how Keel was built" [private, share to link]

  5. 05

    Review

    Human gate

    Agents do

    Run checks and tests, and flag problems in their own changes.

    I decide

    Read every diff, then try the real thing myself.

    Tools

    Claude Code · test suites · accessibility checks

    Example

    [Pick an example, such as a bug an agent caught or missed]

  6. 06

    Ship

    Human gate

    Agents do

    Prepare releases, release notes and deploy steps.

    I decide

    Press the button. Nothing deploys or posts without a yes.

    Tools

    GitHub Actions · GitHub Pages · Claude Code

    Example

    [Pick a release to show]

  7. 07

    Share

    Agents do

    Turn the work into blogs, carousels, LinkedIn posts, covers and short videos.

    I decide

    The voice, the facts and what is ready to go public.

    Tools

    blog · carousel-creator · linkedin-post-gen · video-creator

    Example

    The HDR brightness post on LinkedIn, 18 Oct 2026.

  8. 08

    Reuse

    Agents do

    Follow skills I’ve written instead of starting from scratch.

    I decide

    When a task has repeated enough to become a skill or plugin.

    Tools

    Claude Code skills and plugins

    Example

    Launchpad (13 skills, in final testing), plus carousel-studio, butler and video-studio, used across projects.

The toolbox

Daily, on my machine

Claude Code

Building features, refactors, tooling, deploys and the skills below, in my own repos.

Inside the apps

Claude API

AI features shipped inside my products. [Name the feature, for example in CertPulse]

Docs, designs, decks

Claude artifacts

Research plans, product decision logs, design canvases and design systems, like the one behind this site.

Second opinions

Other models

Web page and mobile app layout ideas, spec refinement, and asset generation. [Other vendors to name]

Skills and plugins I wrote

When a task comes back a second time, I write it down as a Claude Code skill. Skills I use everywhere live globally; skills that only make sense for one product live in that product's repo. Related skills become a plugin.

skills written
28
plugins
5

Plugin · 13 skills · 3 helper agents

In final testing

Launchpad

A Claude Code plugin that takes a product idea from a raw note to a documented, branded, scaffolded product, in seven gated stages. It's the way I built CertPulse, Keel and RevuPulse, written down so the next product starts at full speed.

  1. 1Intake
  2. 2Identity
  3. 3Design
  4. 4Scaffold
  5. 5Build loop
  6. 6Docs
  7. 7Launch

Day to daysetup status handoff adopt brand-sync story

Helper agentsname-scout stack-scout design-reader

Each stage ends at a gate I sign off. Piloted on a real feature before release. [Release date and install link]

15 skills, plus Launchpad’s 13

SkillWhat it doesPlugin
Blog drafts (MDX) from a title and my interview answersStandalone
Post copy, first comment and repost text for a carousel or blogStandalone
LinkedIn company cover options, checked against the logo zoneStandalone
Favicons and every logo asset from one SVG markStandalone
Carousel slides for LinkedIn and other platforms, PNG and PDFcarousel-studio
Learns a design from a carousel and saves it as a templatecarousel-studio
Edits existing slides through a structured change speccarousel-studio
Short product cuts and narrated explainers with Remotion, any productvideo-studio
A morning briefing from yesterday’s report and today’s plansbutler
A daily review of what got done, scored and written upbutler
Narrated one-minute shorts, each explaining one engineering lessonStandalone
The product video, built from the app’s real UI componentsStandalone
Checks alignment, spacing, type and contrast in video scenes before I see themStandalone
Saves tasks, follow-ups and deadlines to Keel from plain conversationKeel for Claude
Answers what’s due, late or waiting on, straight from KeelKeel for Claude

Community skills I use, not mine

Prisma's database skills · Nx monorepo skills · Remotion best practices · ClaudeKit design skills · ui-ux-pro-max · graphify (code knowledge graphs). Picking good ones is part of the job too.

Blueprint

What I'd automate next.

For my own dev workflow: 15 architecture decisions for a platform that turns a GitHub issue, a Slack message or a PRD into a reviewed pull request. How much I have to approve depends on how risky the change is. Designed, not built yet.

The pipeline

  1. RequestIssue · Slack · PRD
  2. Requirement
  3. ADRoptions, blast radius
  4. Risk check
  5. I approve
  6. Plan
  7. Context manifestthe only files code may read
  8. Test plan
  9. Code
  10. Pull request
  11. Quick reviewchanged files, in CI
  12. Preview QAroutes, a11y, console

A deep review of the whole impact surface runs only when I ask for it, or when the risk check flags the change.

Who approves what

RiskFor exampleWhat happens
SafeCopy, CSS fixes, config, docs, analytics eventsAgents open the pull request on their own.
MediumShared components, routing, app logicI approve the ADR before any code is written.
DangerousAuth, payments, infrastructure, CI/CD, secretsMy approval plus an extra review. Never merged automatically.

Six decisions I'd defend

  • 01

    Agents never talk to each other

    They only pass immutable artifacts, and each one links back to the issue it came from.

  • 02

    Smallest context first

    Five retrieval layers. The coding agent may only read the files listed in its context manifest.

  • 03

    Graphs come from code

    Dependency and impact graphs come from static analysis, never from the model.

  • 04

    Budgets stop the work

    Start on the cheapest capable model; going over budget pauses the run for my approval.

  • 05

    Default deny

    Each agent gets only the permissions its role needs, and I can pause or override any stage.

  • 06

    Knowledge lives with the code

    The nearest CLAUDE.md wins. Humans write the guidance; agents read it before code.

Left out on purpose, for the first version

  • Vector databasesRepository knowledge lives in readable guidance files next to the code, so there is no index to keep in sync.
  • EmbeddingsThey go stale and can’t explain why a file was picked. The coding agent reads only the files its context manifest lists.
  • Graph databasesDependency and impact graphs come from TypeScript AST analysis, updated as the code changes. No separate graph store.
  • Conversational memoryAgents share no chat history. Every bit of state lives in immutable, versioned artifacts, so any run can be replayed.
  • KubernetesCloudflare Workers and Queues run the platform. Kubernetes would add operations work with no value for the first version.
  • Event sourcingVersioned artifacts and workflow snapshots already give a full audit trail, without the complexity of event sourcing and CQRS.

Status

Proposed in June 2026, for my React, Vite, TypeScript and Cloudflare monorepos: Workers and Queues, PostgreSQL with R2, a GitHub App, and Claude models by tier (Haiku, Sonnet, Opus only with approval).

Next: architecture diagrams, agent contracts and an MVP roadmap.

House rules

Specs before code.

An agent builds what the spec says, so the spec gets my attention first.

I read every diff.

Generated code ships under my name, so I review it like a teammate's.

Facts stay real.

Agents draft copy; anything they can't source becomes a visible placeholder, never a guess.

Accessibility is a gate.

Contrast, keyboard use and reduced motion are checked before anything ships.

Twice means a skill.

Repeated work gets written down once, as a skill the agent can follow.

Nothing leaves without a yes.

Commits, pushes, posts and deploys wait for me.