ScopePilot

The experiment

ScopePilot began as a radical end-to-end autonomy experiment: could one person provide the mandate and remain accountable while Codex with GPT-5.6 performed the entire delivery lifecycle?

The entrant's role was intentionally narrow but essential. He gave Codex permission to act, supplied access to the required accounts, completed authentication, CAPTCHA, and legal attestations that only a human can make, approved public publication, and retained final responsibility. He did not select the product, write the code, create the tests, prepare the release, make the demo, or compose the submission. Codex handled those parts from blank slate to submission-ready project.

How ScopePilot appeared

The starting brief was not a product specification. The entrant asked Codex to maximize legitimate value in a live competition environment and then largely stepped away. Codex researched opportunities, rejected unsafe or unverifiable shortcuts, compared viable directions, discovered the OpenAI Build Week opportunity, and chose to build a tool that solved the exact problem it was facing: deciding which developer opportunities are actually worth pursuing when rules, eligibility, deadlines, evidence, effort, and payout friction are scattered across pages.

That became ScopePilot. The entrant did not arrive with this idea and initially did not know this was the project being built. Codex proposed it, specified it, implemented it, verified it, released it, demonstrated it, and prepared it for judging.

What Codex actually did

Codex performed the complete technical and operational workflow: opportunity research; product-direction comparison; concept selection; requirements and evidence-policy design; typed domain modelling; UI and interaction design; React and TypeScript implementation; deterministic scoring-engine implementation; automated test creation; debugging; conservative-claims review; browser QA; accessibility and responsive review; documentation; README and license preparation; Git repository work; release verification; GitHub Pages deployment; demo scripting; screen-capture planning; video production and encoding; independent frame, audio, privacy, and codec review; public YouTube upload; public-link verification; Devpost copywriting; media preparation; and submission-form completion.

This is not a vague 'AI-assisted' claim. ScopePilot is the artifact of an agent carrying one product across discovery, design, engineering, testing, documentation, deployment, demonstration, publication, and submission. The human supplied authority, identity, human-only attestations, and final approval; Codex executed the work.

Verifiable contribution trail

The organizers receive the complete Codex session identifier in the private Additional info section. That session is the audit pointer for the full build: the decisions, implementation work, test and release evidence, browser QA, video-production coordination, upload workflow, and submission preparation all live in one continuous Codex work trace. OpenAI can use that identifier to correlate and review the original session.

The raw transcript is deliberately not published on the public project page because it contains private authentication and account information. The repository instead contains a safe, inspectable contribution summary, architecture, tests, release evidence, and public artifacts. This preserves privacy without hiding who did the work.

Inspiration

Developer opportunities rarely arrive as clean specifications. Eligibility, deadlines, AI policies, fees, KYC, deliverables, payout timing, and evidence are often scattered across pages. A large headline prize can look attractive while a hard blocker or unclear rule makes the work impractical. ScopePilot makes that decision explicit before development time is spent.

What it does

ScopePilot is a local-first developer tool that turns bounty and hackathon rules into an evidence-backed execution plan. Users select a timestamped bundled sample or paste rule text. A deterministic TypeScript engine normalizes eligibility, deadlines, fees, KYC timing, AI restrictions, deliverables, payout friction, and unresolved assumptions.

Hard gates override headline rewards. The engine estimates conservative expected value, scores execution friction and evidence confidence, and exposes every reason. Users can edit effort and win-probability assumptions, compare opportunities, inspect the evidence ledger, and export a Markdown work packet with checks, phases, sources, assumptions, and a reverification reminder.

The tool runs without an account, wallet connection, payment, external API key, backend, or hidden network fetch. A URL is treated as a source label. Missing facts remain unresolved and reduce confidence instead of being invented.

How it was built

ScopePilot uses React, TypeScript, Vite, Vitest, Testing Library, Lucide React, and browser Blob/object-URL APIs. Its framework-independent domain engine contains typed facts, hard eligibility gates, scoring rules, confidence and friction inputs, and deterministic output. React manages the analysis, comparison, evidence, plan, and export interfaces.

The public GitHub Pages deployment gives judges a no-login, no-rebuild path. The repository documents setup, architecture, evidence policy, limitations, tested environments, entrant-versus-Codex contributions, and licensing. The release passed 9 test files and 40 tests.

Challenges

The central challenge was not generating code; it was maintaining truth across the entire pipeline. Hard blockers must override rewards, unknown facts must remain visible, a supplied source URL must never be represented as fetched when analysis is local-only, and the same evidence rules must survive implementation, tests, UI, documentation, video narration, and submission copy.

The second challenge was operational autonomy. Building the app was only one part. Codex also had to coordinate review, release, deployment, demo production, public video publication, verification, and the submission workflow while correctly stopping for human-only authentication, CAPTCHA, legal attestations, publication consent, and final submission approval.

Accomplishments

The result is a working public product with reproducible scores, visible reasons, editable assumptions, four evidence states, seven execution phases, opportunity comparison, and portable Markdown output. It requires no secrets or external services and can be tested immediately.

More importantly, the project demonstrates a concrete division of responsibility for agentic development: the human remains the accountable entrant and authorizes consequential actions; the agent performs the end-to-end technical and operational work with an inspectable trail.

What we learned

'AI-assisted' is too vague to describe modern agentic development. The useful questions are: which decisions and actions belonged to the human, which were executed by the agent, what evidence verifies the result, and where did the agent stop for human-only responsibility? ScopePilot answers those questions with the project itself.

We also learned that the largest advertised reward is not the best opportunity. Eligibility, effort, probability, cost, delay, and evidence quality all matter. Analysis becomes actionable only when it produces explicit stop/go gates, a phased plan, and an inspectable evidence package.

What's next

Next steps include optional user-approved source ingestion, richer rule parsers, saved local workspaces, shareable comparison reports, and integrations that pass ScopePilot's typed gates into developer and agentic workflows.

Built With

• github
• lucide-react
• react
• testing-library
• typescript
• vite
• vitest