GECKO

Agentic product validation · MCP

Stop building things nobody wants.

Gecko is an AI founder review board inside Claude Code. It stress-tests your idea, sharpens your ICP, and turns the surviving concept into a fundable PRD — before you write code. You fund a workspace budget; agents pay per task under the hood.

Install · copy the line

$ curl -fsSL https://app.geckovision.tech/install.sh | bash
Verdict: build · narrow · pivot · killAdversarial panel in ~3 minClaude Code MCP · workspace budget

Terminal · 12s loop

live preview
gecko_research · gecko_route · gecko_scaffolddemo

Validation

Debate run

Kill, narrow, or green-light with cited pushback — not polite agreement.

Artifact

PRD in-repo

Fundable doc + tasks under .gecko/.

Who buys first

Claude Code / Cursor power users who can build — but fear building the wrong thing.

Primary ICP: technical founders, senior engineers, and AI-native builders already paying for coding agents. They need product judgment before the repo fills with code. Secondary: MVP studios and hackathon teams that need repeatable discovery artifacts.

Pains

  • Ship fast with AI, then realize the idea was wrong.
  • No disciplined pre-build review — chat bots agree too easily.
  • Market and scope risk, not coding skill.

Early buyer signal

"I can build this weekend — I just don't know if it's worth building." Willing to pay $9–49 per validation run if the artifact is shareable and changes what they ship.

Defer for now

Pure crypto tourists, OpenRouter-only cost optimizers, and enterprises needing Jira governance on day one. We're validation-first; routing and scale come after the PRD is right.

  • I just want to build.

    Gecko outputs a PRD and tasks you can paste into Claude Code — faster than refactoring a dead product.

  • I don't do crypto.

    You top up a workspace budget; stablecoin settlement is infrastructure, not the hero story.

  • Why not ChatGPT?

    Structured adversarial roles, repo-native artifacts, and a build/kill verdict — not a single-thread chat.

The builder loop

Validate first. Scaffold next. Route only when you're building the right thing.

Habits beat hero moments. Start with judgment (debate + PRD), then execution — optional cost-aware routing once scope is honest.

  • Day 1

    gecko_research

    Five-agent verdict on your idea — cited sources, ship/kill signal.

    $0.75

  • Day 2

    gecko_scaffold

    PRD, business plan, and BUILDING.md land under `.gecko/scaffolds/`.

    free

  • Days 3–6

    claude code + gecko_route

    Optional: route subagent calls within your workspace budget — per-call receipts in-terminal.

    pay per call

  • Day 7

    gecko_pulse

    Weekly digest plus upcoming: gecko_eval_project, gecko_research_feature (Sprint 4 — no fixed dates).

    free digest

First run still takes ~3 minutes: fund workspace via frames.ag (email + USDC), paste skill line — see Install.

frames.ag · benchmark

Frames gives agents paid capabilities. Gecko gives founders judgment.

frames.ag is the wallet primitive — email onboarding, stablecoins, policy limits, and x402-friendly access to paid tools without API keys everywhere. Gecko sits on top: the adversarial validation workflow that decides what is worth building before your repo bloats. Same funded workspace: judgment runs, scaffold, and optional routed execution.

New wallet? Start at frames.ag. Existing username path: frames.ag/u/your-username.

Pattern match

Category: agentic product validation — not another agent OS.

  • Not an LLM router product

    Routing is optional execution infrastructure — validation and the PRD artifact are the wedge.

  • Not “crypto-first” software

    You see workspace budget and receipts — stablecoins are how agents settle per task, not the hero.

  • Not competing with frames.ag

    They unlock paid tool access for agents; we unlock product judgment before code.

The debate

Five agents argue so you don't ship blind.

Pro streams an adversarial panel into Claude Code context: CEO-grade skepticism, market bite, scope discipline, builder realism. One settlement per run. Transcript + artifact stay in-repo.

Illustrative transcript pattern from a Pro session — formatting matches live output.

First paid product

One validation run → one screenshot-worthy artifact.

The debate is the mechanism; the deliverable is what you ship. A paid run ends with a structured doc in your repo — not a meandering chat log.

  1. 01

    1. Verdict

    Build · Narrow · Pivot · Kill — with one clear recommended move and why.

  2. 02

    2. ICP & wedge

    Who hurts most without this, exact wedge line, and who to ignore for V1.

  3. 03

    3. Market risks

    Demand, timing, competition, and the top reasons the idea could fail — cited where possible.

  4. 04

    4. MVP scope

    Acceptance criteria, explicit non-goals, and Scope Cop flags on hidden V2 work.

  5. 05

    5. PRD (fundable shape)

    Problem, solution narrative, success metrics, and narrative a teammate or investor can read cold.

  6. 06

    6. Next tasks

    Ordered implementation tasks to paste into Claude Code after validation (scaffold when you graduate).

Optional follow-on: gecko_scaffold after a Build/Narrow verdict — PRD and BUILDING.md under .gecko/scaffolds/.

Personas

Your AI founder review board lives beside your PRD.

After install they live in .claude/agents/. Claude Code invokes them during validation, scaffold, and scope checks — not as generic chat toys.

  • research-analystEvidence-first
    Explores the result. Runs free `gecko_ask` follow-ups grounded in indexed sources.show prompt →

    You are the research analyst. Survey TAM, market dynamics, and 3 concrete comparables. Cite every source by chunk_id. Never speculate without an anchor.

  • market-validatorAdversarial
    Adversarial reader of the validation report. Pushes back on weak demand signals.show prompt →

    Your job is to disagree well. Pick the weakest TAM claim and the softest demand signal. Demand a sharper wedge or kill the line. Be bitey, never cruel.

  • technical-architectBuilder-pilled
    Translates `prd.v1_scope` into Next.js + Tailwind + Supabase architecture.show prompt →

    Propose the V1 stack. Default to Next.js + Tailwind + Supabase. Add Solana when the primitive is on-chain. Be concrete, opinionated, no "depending on requirements".

  • validatorScope cop
    Pre-implementation sanity check. Catches V2 features hiding in V1 scope.show prompt →

    Read every acceptance criterion. Flag any that requires more than 4 days of work, more than 1 user, or any feature that should be V2. Reject; don't reformat.

  • builderShip lane
    Scaffolds via `npx create-next-app`. Implements V1 only. Cites PRD lines per commit.show prompt →

    Run `npx create-next-app`. Implement only the V1 acceptance criteria. Every commit message references the prd.acceptance_criteria id. No V2 sneaking in.

Personas ship with the install — no prompt engineering required.

Optional · execution

After validation: stay inside your workspace budget.

When you're ready to execute, optionally route Claude Code subagent calls with transparent per-call receipts. This is not the wedge — it's infrastructure for builders who already passed product judgment.

routed_calls.log
───────────────────────────────────────────────────
This week: routed 142 calls · budget vs. naive default: lower

Example · per 100 calls

Premium model default path

$1.80 / 100 calls

Gecko routed path (illustrative)

$0.48 / 100 calls

~73% lower vs. illustrative premium baseline

Routing uses a task-hint matrix; numbers above are illustrative. Real receipts print next to each line in-terminal.

Claude Code

Install in 30 seconds

macOS / Linux. Python 3.11+. One copyable line — then paste the skill URL in your IDE. Need a wallet? frames.ag spins one up with email + USDC funding — agents stay inside your workspace budget.

$ curl -fsSL https://app.geckovision.tech/install.sh | bash
Then paste this into Claude Code:
Read https://app.geckovision.tech/skill.md and follow the instructions.

What you pay

Pay for judgment — then optional routed execution.

Lead with validation runs and PRD artifacts. If you use gecko_route, per-call compute bills against the same workspace — with line-by-line receipts.

  • Preview

    Free

    One lightweight idea roast. Preview how the panel pushes back before you fund a full run.

  • Validation

    $9–19/ run

    Full adversarial validation — verdict, cited research, build / narrow / pivot / kill signal.

  • PRD + ship

    $29–49/ run

    Validation plus fundable PRD, MVP scope, GTM angle, landing narrative, and first implementation tasks.

  • Founder workspace

    Coming soon

    $99/ mo

    Saved projects, repeat validation, export/scaffold workflows, workspace budget controls.

Optional: ~10% markup on routed calls when using gecko_route — surfaced in-terminal, not as marketing fine print. Validation pricing is the hero.

Go-to-market

Launch wedge: paste your idea — get a build/kill verdict and a fundable PRD.

Distribution follows the artifact. Optimize for shares: crisp verdicts, sharp ICP lines, and scope discipline people recognize in one screenshot.

Channels

  • X / GitHub — Claude Code, Cursor, Codex, OpenCode power users.
  • Solana & x402 builders — agentic payments credibility without leading the landing with wallets.
  • Hackathons & AI founder Discords — validation before demo deadline.

Content loops

  • Public idea teardowns and “Killed by Gecko” threads.
  • Before/after positioning rewrites from real runs.
  • Shareable PRD excerpts (anonymized) and founder testimonials.
  • Contrast: building blind in v0 / Lovable / raw agent chat vs. validated PRD first.

Partnerships

  • frames.ag — wallet + policy primitive; we’re the judgment workflow on top.
  • Hackathon orgs — “paste idea → get verdict” booth flows.
  • AI coding tool communities — complementary pre-build layer, not a replacement IDE.

Cadence

Sprint shipping, not slide-deck quarters.

Shipping order follows positioning: validation moat first, routing as execution infra, network effects last.

  • ✓ Now

    Phase 1 — Validation artifact

    Adversarial debate → build/kill verdict → structured PRD output in-repo (screenshot-worthy).

  • • Next

    Phase 2 — Builder workflow

    Export to tasks / issues, Scope Cop on drift, scaffold only after validation passes.

  • ○ Later

    Phase 3–4 — Budget + distribution

    Workspace caps & receipts; teardown gallery, templates, shareable PRD cards.

Track the repo: github.com/ernanibmurtinho/gecko-claude →

Get waitlist updates

Email for Founder workspace ($99/mo) and mainnet billing — install stays the primary path.

Margin note

Gecko uses x402-compatible rails so agents can settle per-task without you wiring every API vendor. For nitty-gritty receipts, run gecko-mcp economics <session_id> after any paid session — optional depth, not the hero story.

[ Settlement — Solana · stablecoins · HTTP 402 ]

Who builds this

Two builders. One repo. Real on-chain receipts.

Indie. Open source. No VC pressure on the unit economics.