Micro-Tool Playbook
Phase 1 · Foundations
Coding Tools

Primary tools for building and deploying micro-tool websites. Install at least one AI coding agent before starting.

Antigravity IDE 2.0
Primary agentic coding IDE by Google DeepMind
antigravity.google ↗
OpenCode AI
AI coding agent with OpenRouter auto-router
opencode.ai ↗
OpenRouter
Model routing for OpenCode — access any LLM
openrouter.ai ↗
Blackbox AI
Additional coding assistant option
Kilocode AI
Additional coding assistant option
opensrc (Vercel)
Fetch any npm package's source code for AI agent context
github.com/vercel-labs/opensrc ↗
opensrc — source code for agents
🤔 Why opensrc exists

AI agents are trained on documentation — but docs go stale fast. When you use a package like zod, drizzle, or astro, the agent often hallucinates function names, wrong argument shapes, or APIs that were removed in the latest version. opensrc solves this by putting the actual source code on disk so the agent can search it instead of guessing.

When to use opensrc

The agent calls a function that doesn't exist in the package

Docs are weak, stale, or too abstract for what you need

You're integrating a fast-moving SDK (AstroJS integrations, Drizzle ORM, etc.)

The agent keeps installing alternative packages instead of finding the right API

You want the agent to follow the package's actual internal patterns, not examples from 2022

Install & quick usage
npm install -g opensrc

# Fetch + cache a package (instant on repeat runs)
opensrc path zod

# Search a package's source with ripgrep
rg "parse" $(opensrc path zod)

# Read a specific file directly
cat $(opensrc path zod)/src/types.ts

# Works with any registry (npm, pypi, etc.)
find $(opensrc path pypi:requests) -name "*.py"
How to use it with your AI agent

After fetching, put the path in your AGENTS.md or tell the agent directly. The key insight: don't paste the source into chat — let the agent search it on disk.

tell your agent where to look
When working with zod, reference the local source under:
`$(opensrc path zod)`
Do not guess API names. Search the source first, then implement.
feature prompt with source grounding
Build a form validation module using zod.

Before coding:
1. Search `$(opensrc path zod)/src` for the correct schema API and .parse() patterns.
2. Note which files/functions you used as reference.
3. Implement only the minimal validation function.
4. Keep the diff small.
5. Tell me which source files you looked at.
Why not just paste docs into the prompt?

Context window limit. Full docs = thousands of tokens. On-disk search = zero tokens until the agent reads what it needs.

Docs lie. README examples often use old APIs. Source code is always current.

Types don't lie either. TypeScript .d.ts files show exact function signatures — more reliable than any example.

opensrc path fetches on first use, then returns the cached path instantly. Pair it with the Source Code Context agent skill in the workflows section below.
Agent Skills & Context Engineering

Install these before starting any project. Skills give your AI agent specialized knowledge it doesn't have by default.

Required skills (install for every project)
🎨Web design guidelines

Vercel's design system — consistent, professional UI patterns.

npx skills add vercel-labs/agent-skills --skill web-design-guidelines
💨Tailwind v4 docs

Agents know v3 well but struggle with v4 — this fixes that.

npx skills add Lombiq/Tailwind-Agent-Skills
Frontend design

Aesthetic direction and visual identity for distinctive UI.

npx skills add anthropics/skills --skill frontend-design
🚀AstroJS skill

Latest AstroJS docs via MCP for accurate syntax.

skills.sh/astrolicious/agent-skills/astro
Local workflow skills (install from local skills/ directory)
🔄Agentic engineering

End-to-end framework for building with AI agents. Harness selection, context management, and loop refinement.

npx skills add ./skills/agentic-engineering-workflow
🦧Service layer & cleanup

Separates orchestration actions from reusable operations. Keeps code clean and avoids AI duplication.

npx skills add ./skills/code-structure-cleanup
🔁Grep loop review

Auto-research PR-fix loop. Iteratively resolves review feedback and runs tests until clean.

npx skills add ./skills/grep-loop-review-workflow
📂Source code context

Supplies local repository references to stop AI hallucination and ensure correct SDK usage.

npx skills add ./skills/source-code-context
Vercel DESIGN.md — run once per project

Dramatically improves AI-generated UI quality. Creates a design token file the agent references.

npx getdesign@latest add vercel
Source code as agent context

When your agent hallucinates function names, give it real source code. Put the repo in a reference folder and add an instruction to AGENTS.md.

add to AGENTS.md
When working with [library/tool], reference the local source under:
`reference/repos/github.com/company/project`.
Do not guess API names. Search the source first, then implement.
feature prompt with source context
Build [feature]. We use [library/tool].

Before coding:
1. Search `reference/repos/github.com/company/project` for the correct API and patterns.
2. Identify the files/functions/examples you used as reference.
3. Implement only the minimal service function and one calling route/component.
4. Keep the diff small.
5. Explain which source files you referenced.
Don't paste entire repos into chat. Put the source on disk and point the agent to it — let it search the files itself.
AGENTS.md Setup

Place in project root. The agent reads this first at the start of every session. This is the single most important file for agent behavior.

AGENTS.mdproject root
Always Use:
- astro, tailwind-4-docs, web-design-guidelines (these 3 skills every project)
- DESIGN.md for this project's visual design

Install MCPs for your tech stack before starting.
Start new sessions frequently.
Always use git — commit after each working milestone.
Also create CLAUDE.md, GEMINI.md etc. for agent-specific rules. Each loads automatically when that agent starts.
Phase 2 · Build
1Find the Problem

The hardest step. You need a small, specific problem with no great existing solution.

What makes a good problem

Affects you personally or someone you know

Seems small — less competition, easier to rank

No great existing tool solving it properly

Where to look

Notice what you search for and can't find a good answer to

Reddit complaints in relevant subreddits

Quora questions with weak or no answers

Ask Claude/Gemini: "What small everyday problems could be solved with a simple web tool?"

Look at existing tools and note every weakness

Validation

Google your keyword — check first 4 pages. Government site or Quora on page 4 = goldmine opportunity.

Note every weakness in the top results

Write down what your tool will do better

2Keyword Research

Validate search volume before building anything. Tool: Ahrefs Free Keyword Generator

Enter your main keyword — even 1,000 monthly US searches is enough

Questions tab — copy all FAQs. These become your FAQ section later.

Related terms tab — find supporting keywords for your SEO content

Type keyword in Google + Space — autocomplete = real searches from real users

Target US traffic. US CPM rates are far higher — 1,000 US visitors can earn as much as many more visitors from other regions.
3Domain Name

Domain is a ranking factor. Tool: Instant Domain Search

.com only — no exceptions. .com ranks easiest and is most trusted.

Primary keyword must appear in the domain

Shorter is better, but keyword presence matters more than length

No hyphens

Don't buy the domain before writing code. Confirm the concept works first, then buy.
Where to buy (~₹1000/year)
Namecheap
Best interface — requires card, no UPI
GoDaddy
UPI supported, good offers
BigRock
UPI supported — ~₹883/year
Hostinger
UPI supported — ~₹904/year
4Dev Setup

One-time install. Do this before writing any code.

Git — version control (commit after every working milestone)

VS Code — code editor

Node.js — required to run AstroJS

Claude Code / Cursor / Gemini CLI — AI coding agent

Initialize AstroJS project
npm create astro@latest .
# Press Enter for all defaults
# Choose "Basic" template
# Say Yes to initialize Git
Add Vercel DESIGN.md
npx getdesign@latest add vercel
5Build the Website

Paste this prompt in your AI coding agent. It will analyze the competitor and start building.

website creation promptClaude Code / Antigravity
I have initialized a new AstroJS project. Use the astro-docs MCP,
tailwind-4-docs skill, and web-design-guidelines skill.
Also use @DESIGN.md. Keep the design like Vercel.

Name: [Your Tool Name]
Domain: [yourdomain.com]

Create a [describe your tool]. My competitor is [URL] — go to this
website, analyze it, identify weaknesses, and build a better version.
Do not copy the competitor's design or UI.
Use MPA architecture for best SEO.
After first build
npm run dev
Use /clear in Claude Code before each fix session to keep token usage low.
Common additions after first build

Dark mode toggle

Mobile responsiveness — test via Chrome DevTools mobile icon

Multiple language support — separate URL paths = international SEO

Phase 3 · Polish
6On-Page SEO

Run in a fresh session after /clear.

SEO promptfresh session
Do the on-page SEO of this website for:
Main Keyword: [your keyword]
Supporting Keywords: [comma-separated list from Ahrefs]

Also add proper OG meta tags. Write 600 words about the tool
on the home page for SEO.
SEO essentials checklist
<title> tag contains your primary keyword
<meta description> under 160 chars, contains keyword
All images have descriptive alt attributes
Clean URLs — /online-ruler not /page?id=123
600-word content section on the home page
7FAQ Section

Drives long-tail traffic and can trigger Google rich results (higher click-through rates).

FAQ prompt
Add an SEO-friendly FAQ section using JSON-LD structured data
for these questions:
[paste questions from Ahrefs "Questions" tab + Google "People Also Ask"]

Use FAQ JSON-LD schema with @type: FAQPage and Question/Answer pairs.
Most competitors skip the FAQ entirely. This alone can tip rankings in your favor.
8Required Pages

AdSense rejects sites without these four pages. Generate all at once.

required pages prompt
Create these pages as separate MPA routes for best SEO:
- Privacy Policy
- Terms & Conditions
- About Us
- Contact Us

Make them visible and linked in the home page footer and header.
This should be a multi-page application (MPA) for best SEO.
Also add to the project
robots.txt with sitemap link
sitemap.xml with all page URLs
Error pages (404, 500)
Google Analytics tracking code in site header
Phase 4 · Launch
9Deploy to Cloudflare Pages
npx wrangler login

Then tell your AI agent: "Deploy this to Cloudflare Pages and add a deploy command to package.json."

Future deploys
npm run deploy
Fix duplicate content issue

Add a _headers file in /public to stop Google indexing your .pages.dev domain:

/public/_headersCloudflare
https://yoursite.pages.dev/*
  X-Robots-Tag: noindex
Verify in Chrome DevTools (Network tab) — X-Robots-Tag: noindex should appear on .pages.dev but NOT on your .com domain.
10Buy & Connect Your Domain

Cloudflare → Domains → Add a Domain → select free plan

Delete all existing DNS records

Add A record: Name @, Value 8.8.8.8 (placeholder)

Copy the two Cloudflare nameservers provided

Go to your registrar → update nameservers → wait 10–30 min

Workers & Pages → your project → Settings → Custom Domains → add domain

Repeat for the www version. Both go live within 15 min.

11Submit to Search Engines

Google Search Console — add domain property, verify via TXT DNS record, submit sitemap.xml, request indexing on homepage

Bing Webmaster Tools — sign in with Google, import from GSC, submit URL for indexing

Bing powers DuckDuckGo, Yahoo, and multiple AI search engines — worth the 5 minutes.
12Apply for Google AdSense

Wait until you have at least 10 daily users consistently (Google Analytics → Real-time).

Go to adsense.google.com ? Add your site

Paste AdSense snippet via AI agent: "Add this AdSense script to the site header" ? deploy

Verify ownership via ads.txt (agent creates this)

Click Request Review — takes days to weeks

Once approved, enable Auto Ads

Reference
Prompt Templates
Context compression (new session)
compact promptpaste at session start
CRITICAL CONTEXT COMPRESSION: Summarize our entire session up to this point.
Include: 1) The overarching goal, 2) Key technical decisions made,
3) Files modified and current state, and 4) The exact next steps required.
Format as a dense, context-rich prompt I can paste into a new session to
instantly resume. Output ONLY the summary prompt, nothing else.
Agentic engineering starter
general agent prompt
We are building using an agentic engineering workflow.

Rules:
1. Keep the change small and reviewable.
2. Search existing code before creating new abstractions.
3. If using a package/framework, reference its source or official repo before guessing APIs.
4. Build the minimal working version first.
5. After it works, run a code-structure cleanup pass.
6. Run relevant tests/typechecks.
7. Summarize what changed, what was tested, and what needs human judgment.

Task: [describe the feature or fix here]
Agent Workflows & Skills

System-level workflow skills from your local skills/ directory. These are reusable operating patterns for every AI coding session — read them once, apply them always.

🔄 Skill 1 · Agentic Engineering Workflow

The high-level operating system for building with AI agents. This is not "ask the AI to build everything and hope." The human decides the outcome, the agent does mechanical work, tests and reviews keep it honest.

When to use: You're building an MVP, feature, or internal tool. You want a repeatable AI coding workflow instead of random prompting. You're using Cursor, Claude Code, Gemini CLI, or Antigravity IDE.
Full workflow (8 steps)

1. Pick the strongest harness/model you can access. The harness is the wrapper around the model: file search, terminal, browser, tools, system prompt, and project memory. The model matters, but the harness determines what the model can actually do.

2. Keep the task small. Ask for one feature, one fix, or one reviewable unit at a time. If a plan is too large, ask the agent to split it into PR-sized chunks first.

3. Give source code as context when docs are not enough. If you're using a package, SDK, or open-source tool, put its source in a reference folder and tell the agent to search it before coding. Use opensrc for npm packages.

4. Build the minimal feature first. Do not refactor the whole app while building the feature. Get the smallest working version running before anything else.

5. Run a cleanup pass. After the feature works, ask the agent to find duplicated runtime mechanics and move them into reusable service-layer modules.

6. Run a review-fix loop. Use tests, typechecks, and AI/human review. Feed review feedback back into the coding agent. Keep fixing until the PR is clean or a human decision is needed.

7. Launch earlier than feels comfortable. A semi-functional MVP with user feedback beats a perfect private project. Competitors ship while you polish.

8. Apply security guardrails. Use 2FA, a password manager, avoid young packages, and ask your agent to check if your project is exposed when a package breach trends.

Copy-paste starter prompt
agentic engineering starter
We are going to build this using an agentic engineering workflow.

Rules:
1. Keep the change small and reviewable.
2. Search the existing code before creating new abstractions.
3. If using a package/framework, reference its local source or official repo before guessing APIs.
4. Build the minimal working version first.
5. After it works, run a code-structure cleanup pass.
6. Run relevant tests/typechecks.
7. Summarize what changed, what was tested, and what still needs human judgment.

Task:
<describe the feature or fix here>
Common pitfalls
Letting the agent think for you. The agent is a worker, not the product owner. You decide the outcome.
Overloading context. More context is not always better. Give the exact files/folders it needs, not everything.
Huge PRs. Review loops break down when the diff is thousands of lines. Split early.
No cleanup pass. Working code can still be duplicated and hard for future agents to debug.
Never launching. Waiting for perfect is how competitors ship before you do.
Security guardrails
Never install a package less than 14 days old without explicit human approval
Use 2FA via authenticator app, not SMS
Use a password manager
Never paste secrets into prompts or screenshots
When a package breach trends, ask agent to inspect your local projects for that package/version
Verification checklist
Task was split into a small reviewable unit
Agent searched relevant existing code before editing
External package behavior was checked against source or official docs
Feature works locally
Cleanup pass removed obvious duplication
Tests/typechecks ran or the reason they couldn't run is stated
Security-sensitive changes were explicitly reviewed
🧹 Skill 2 · Service Layer & Code Structure Cleanup

Two-layer separation: Actions orchestrate domain rules (the "why/when"), while a service layer centralizes reusable operational mechanics (the "how"). This prevents duplicated code, inconsistent behavior, and bugs fixed in one path but not others.

When to use: Multiple callers need the same low-level operation. You're copy-pasting logic between files. A bug fix in one workflow doesn't propagate to others. A feature works but the code feels messy. The agent created similar helper functions in multiple files.
Don't use when: Logic is truly domain-specific and used by only one caller. Don't use this as permission to redesign the whole app.
Core pattern
Orchestration Layer (Actions)          Service Layer (Shared Mechanics)
├── owns business rules                ├── owns reusable operations
├── owns state transitions             ├── owns provider/SDK interactions
├── owns auth/ownership checks         ├── owns command execution details
├── owns failure classification        ├── owns health checks / readiness
├── owns retries / user-facing errors  └── returns structured results
└── calls service functions
Rule of thumb

"What this product flow means" → keep in actions/routes

"How to do this operation reliably" → move to service layer

Good service function design
// ✅ Good: composable capability blocks — each caller picks what it needs
createManag edSandbox(...)   // one job
prepareRepo(...)             // one job
detectPackageManager(...)    // one job
installDependencies(...)     // one job

// Each function:
// - accepts explicit params (no hidden global state)
// - returns structured output: { ready, previewUrl, port }
// - never reads from database directly
// - makes failure explicit (no silent swallowed errors)
Cleanup pass prompt (run after feature works)
code structure cleanup
The feature is working. Now do a code-structure cleanup pass.

Goal:
- Find duplicated runtime mechanics, repeated API calls, repeated parsing,
  repeated validation, or repeated business logic.
- Move repeated mechanics into reusable service-layer functions/modules.
- Keep domain policy in the calling route/action/component.
- Do not change user-facing behavior.
- Keep the diff small.

Process:
1. Inspect the files touched by the feature.
2. Identify repeated logic and name the duplication clearly.
3. Propose the smallest service-layer extraction.
4. Implement it.
5. Run the relevant tests/typechecks.
6. Summarize exactly what got simpler.
Migration steps when extracting shared logic

Write the flow in action code first (clear behavior)

Mark repeated operational chunks across callers

Extract only repeated, non-domain chunks to service

Replace one caller → verify → replace remaining callers

Keep domain policy in actions (auth, status transitions, error classification)

Run verification: typecheck, lint, confirm all flows still work

Anti-patterns to avoid
God service — one huge function hiding all control flow
Leaky service — service mutates database tables directly
Inconsistent API — each function uses different argument styles and error semantics
Over-abstraction — extracting logic used by only one caller
Refactoring the whole app — keep scope tied to the feature
Mixing cleanup with a new feature — cleanup is always a separate pass
Only formatting code — pretty code can still contain duplicated logic
Moving domain policy into services — services handle mechanics, not business decisions
Verification checklist
User-facing behavior stayed the same
Repeated mechanics were actually reduced
Calling files became simpler
Relevant tests/typechecks ran
Diff stayed focused on the feature area
🔁 Skill 3 · Grep Loop Review Workflow

An auto-research-style loop for code review: create small PR → let a review tool or human inspect it → feed review back to the coding agent → agent fixes → review again → repeat until clean.

When to use: You have a small PR/feature ready for review. Feedback is specific enough for an agent to act on. Tests or typechecks can confirm the fix. You want the agent to keep going until the review is clean.
Don't use on: massive PRs or unclear product decisions. The loop breaks down when the diff is thousands of lines.
Pre-flight check (run this first)
before starting the loop
Is this PR too large for a reliable review loop? If yes, suggest how to split it.
Review-fix loop prompt
review-fix loop
Run a review-fix loop for this PR.

Inputs:
- Current branch: <branch-name>
- Review feedback: <paste feedback or point to reviewer output>
- Required end state: tests pass, reviewer issues resolved, no unrelated rewrites.

Rules:
1. Read the PR diff first.
2. Read the review feedback.
3. Fix only issues that are real and relevant to this PR.
4. Add or update tests for each bug fix when possible.
5. Run the relevant tests/typechecks.
6. Commit/push the fix if this workflow is allowed to push.
7. Stop only when the PR is clean or when blocked by a decision that needs a human.
Human guardrails
Use the loop on small PRs only — accuracy degrades on large diffs
Reviewers can produce false positives — don't blindly accept every comment
Agents can over-fix and rewrite unrelated code
A clean review ≠ proof the product is valuable; it only means this diff looks clean
Define what "done" means before starting the loop
Common pitfalls
Thousands of lines in one PR. The reviewer and coding agent both lose accuracy at scale.
No tests. The loop needs objective checks, not just vibes.
Blindly accepting every review comment. Some comments are wrong or irrelevant.
No stop condition. Define what "done" means before starting.
Verification checklist
PR is small enough to review reliably
Agent read the diff before editing
Agent fixed only relevant issues
Tests/typechecks passed or blockers were stated
Final summary lists resolved review items
📂 Skill 4 · Source Code as Agent Context

Code is often the best source of truth. Docs can be outdated, examples can be incomplete, and blog posts lag behind the current API. When an agent has access to the actual repo source, it can search for real function names, types, examples, and edge cases. Use this skill to stop the agent from guessing.

When to use: You're integrating a package, SDK, API client, framework, or open-source tool. The agent keeps hallucinating functions that don't exist. Docs are weak, stale, or too abstract. You want the agent to follow the package's actual internal patterns.
Setup (3 steps)

Identify the package/repo you're using

Add the repo source into a clearly named folder: reference/repos/github.com/company/project — or use opensrc path <package> for npm packages

Add a short instruction in AGENTS.md, CLAUDE.md, or your harness memory (see prompt below)

Add to AGENTS.md
AGENTS.md instruction
When working with <library/tool>, reference the local source under:
`reference/repos/github.com/company/project`.
Do not guess API names. Search the source first, then implement.
Feature prompt template
grounded feature prompt
Build <feature>. We use <library/tool>.

Before coding:
1. Search `reference/repos/github.com/company/project` for the correct API and patterns.
2. Identify the files/functions/examples you used as reference.
3. Implement only the minimal service function and one calling route/component.
4. Keep the diff small.
5. Explain which source files you referenced.
Real example (Daytona sandboxes)
example prompt
We need to integrate Daytona sandboxes into this app.
Reference the local Daytona source under `reference/repos/github.com/daytonaio/daytona`.
Find the current SDK pattern for creating a sandbox and running a command.
Then implement only the minimal service function and one calling route.
Common pitfalls
Dumping too much context into chat. This bloats the context window. Let the agent search files on disk instead.
Trusting old docs over current code. Fast-moving packages change quickly — source is always current.
Letting the agent install alternatives. If it can't find the API, make it search the source before adding new dependencies.
No path convention. Use a predictable folder name so every future agent knows where references live.
Verification checklist
Reference source exists in a stable, predictable folder
Agent was explicitly told where to search
Agent reported which files/functions it referenced
No random replacement package was installed without approval
The implementation matches current source-code patterns
Launch Checklist

Go through this list before considering your site ready. Every item is non-negotiable for AdSense approval.

Create website with prompt (give competitor URL)
Logo & favicon from logofa.st
Real favicon generator (multi-size for all devices)
Mobile responsive — test via Chrome DevTools
On-page SEO — 600 words about the tool
FAQ section with JSON-LD structured data
Privacy Policy, About Us, Terms & Conditions, Contact Us
Error pages (404, 500)
robots.txt with sitemap link
sitemap.xml with all page URLs
Google Analytics tracking code
_headers file for Cloudflare (noindex on .pages.dev)
Revenue Model

SEO drives free organic traffic. AdSense places ads. Zero marginal cost — build once, earn forever.

₹10k–50k
per month
1 tool, 1,000 daily US visitors
₹1–4L
per month
10–15 tools with traffic
4–6 mo
typical time to
first meaningful ranking
Why AstroJS + Cloudflare

Pure static HTML — best output for search crawlers

No JS hydration overhead on non-interactive pages

Perfect Core Web Vitals out of the box

MPA architecture — far better for SEO than SPAs

Cloudflare acquired Astro — native CDN support globally

Built for fast execution. Ship more, overthink less.