Awesome Goal Prompts — Coding Agent Rescue Contracts

When Claude Code, Codex, Cursor, or another coding agent starts making broad edits, paste a contract that says exactly what to inspect, what not to touch, how to verify, and when to stop.

This repo keeps 314 runnable /goal contracts for engineering work. Start with the provenance-backed rescue prompts below; use seed patterns only when you need a raw shape to adapt.

Search the full catalog: https://majiayu000.github.io/awesome-goal-prompts/

A good goal is not a wish. It is a runnable contract: one goal, enough context to inspect, hard constraints, verifiable completion, and stop rules for uncertainty or risk. This repo turns that contract shape into a catalog you can search, inspect, adapt, and copy.

The public catalog starts with 114 source-backed examples drawn from official docs, public GitHub threads, tutorials, forum posts, and tool READMEs. The other 200 reusable seed patterns are kept in Seed Patterns so they do not dilute provenance-backed examples.

Why This Exists

Most prompt lists stop at catchy instructions. This catalog is for the moment after an agent starts drifting: the task is real, the repo has constraints, and "try harder" is not enough. Each contract gives the agent a narrow job, required context, explicit boundaries, proof, and stop rules.

• Source-backed where possible: external examples keep a public URL, source type, evidence phrase, and generated evidence summary.
• Runnable by design: every prompt includes GOAL, CONTEXT, CONSTRAINTS, DONE WHEN, VERIFY, OUTPUT, and STOP RULES.
• Search quality is tested: representative user queries must retrieve the expected contract in CI.
• Seed patterns are separated: reusable patterns stay available, but the main catalog leads with source-backed contracts.

Start With Ten Rescue Prompts

These are the front door. Each one is source-backed, tied to a common coding-agent failure mode, and links to the full copyable prompt.

The provenance-backed library stays below as the primary reference catalog.

Contents

• Why This Exists
• Start With Ten Rescue Prompts
• Source-Backed Catalog
• How To Write A Good Goal
• Catalog Health
• Templates
• Quality Bar
• Sources And Caveats
• Contributing

Source-Backed Catalog

The source-backed index lives in prompts/source-backed-goals.md, and the searchable UI defaults to source-backed examples in the GitHub Pages catalog.

Reusable patterns that are not backed by public sources live in Seed Patterns.

workflow

• Verifiable End-State Contract - Complete one goal only when a verifiable end state is met.
• Four Files Walkthrough - Create four note files across turns and verify each contains its number.
• Meta Goal Prompt Generator - Ask the agent to inspect the session, repo, history, and docs before writing the actual /goal prompt.
• AGENTS.md Goal Workflow - Use AGENTS.md rules together with /goal so long-running work keeps repo-specific constraints.
• Plan-Then-Goal Execution - Use plan mode to define the work, then start a new goal session to implement the plan completely.
• Measurable Goal Structure - Write goals with a clear target, proof requirement, and explicit limits.
• Non-Interactive Goal Creation - Create and confirm an active goal during non-interactive Codex execution before continuing.
• Prep A Goal Workspace - Prepare a goal workspace with board, notes, receipts, and an exact /goal command.
• Long Goal With Constraints - Use a longer goal template with repo path, constraints, plan pointer, and execution order.
• User-Facing Coherence Closure - Finish a coherence pass so CLI help, docs, JSON/plain output, colors, prompts, flags, and next-action grammar stay aligned.

migration

• Visual Migration With Playwright - Migrate a project while preserving screen output and checking it with Playwright.
• Feature Port With CI Green - Port a feature from another repo, include tests, and get CI green.
• Vue 2 To Vue 3 Visual And Unit Gate - Migrate listed Vue screens and stop only when visual and unit tests pass.
• Finish Migration Keep Tests Green - Use /goal to complete a migration while keeping the relevant tests green.
• Module API Migration - Migrate a module to a new API while keeping call sites compiling and tests passing.
• Moment To Day.js Migration - Replace Moment.js with Day.js while preserving date output across edge cases.
• React 19 Migration - Migrate a project to React 19 and continue until the build passes.
• Pydantic V1 To V2 Migration - Migrate a project from Pydantic v1 to v2 while preserving API behavior.

prototype

• PLAN.md Milestone Prototype - Implement a PLAN.md-driven prototype with tests at each milestone and browser verification.
• Canvas Puzzle PLAN.md Prototype - Implement PLAN.md milestones for a canvas puzzle prototype and prove e2e passes.
• Rift Salvage Game Goal - Build a 2D combat game prototype with assets, combat, boss logic, and browser verification.

prompt-optimization

• Eval-Driven Prompt Optimization - Optimize prompts against an eval suite until the target score or pass rate is reached.
• Router Prompt Eval Score - Improve a router prompt against an eval directory until the result score reaches a target.
• RAG Chat Flywheel - Iterate on code, tests, and metrics to improve a document-chat RAG system.

testing

• Auth Tests And Lint Clean - Keep working until auth tests pass and the lint step is clean.
• Ruff Clean Source Tree - Fix every lint error in src and prove ruff passes.
• TypeScript ESLint Coverage Gate - Resolve TypeScript errors, pass tests, clear ESLint warnings, and keep coverage above a threshold.
• Fix Hermes CLI Tests - Fix failing Hermes CLI tests until the project test script passes.
• Add Authentication Tests - Create unit tests for an authentication module in a Jules session.
• Add UserService Unit Tests - Add unit tests for UserService and raise target coverage to the documented threshold.
• Parallel Test Coverage Recovery - Find low-coverage modules and open separate test-improvement PRs for each module.
• Single Vitest Case Fix - Fix a quiz application until one named Vitest case passes.
• Full Quiz Test Recovery - Repair the quiz app until the full Vitest suite exits cleanly.
• Auth Coverage Lift - Raise authentication code coverage from the documented baseline to the documented target within a scoped edit boundary.
• Auth Test Repair Boundary - Fix failing auth tests while preserving the documented file boundary.
• Coverage Autoresearch Loop - Iterate on tests until coverage reaches the documented target.
• Test And TypeScript Clean - Keep working until tests exit cleanly and TypeScript errors are gone.
• Go Race Cleanup - Eliminate data races detected by the Go race detector.
• Tests And Lint Completion - Run a /goal loop until all tests pass and lint is clean.
• Tests Pass And PR Ready - Keep Claude Code working until tests pass and the PR is ready for review.
• Flaky Auth Tests Goal - Use a Claude goal plugin example to find and fix flaky authentication tests.
• Improve Benchmark Coverage - Use /goal to improve benchmark coverage and persist the command in history.
• Batch Fix Bugs - Use a Claude Code goal to fix a numbered batch of bugs without looping on missing skills.
• GOAP Coverage Target Plan - Raise test coverage with an explicit test pyramid across unit, integration, and end-to-end coverage targets.

docs

• Weekly Changelog Coverage - Ensure CHANGELOG.md includes an entry for every PR merged this week.
• Contributor README Rewrite - Rewrite README installation, run, test, and architecture guidance for new contributors.
• Public API Docs Coverage - Add JSDoc and examples for public functions while keeping documentation links valid.
• Payment Retry Logic Diagram - Explain payment retry behavior as a browsable HTML page with a diagram for developer or support review.
• Implementation Notes Decision Ledger - Keep live implementation notes and the final run decisions document aligned around decisions, deviations, tradeoffs, and open questions.

investigation

• Session Drift Report - Investigate session ID drift during mid-run compression and write a report.
• Billing Empty State Root Cause - Find why active subscriptions show an empty state without changing pricing or webhook code.
• Checkout Crash Regression Fix - Reproduce a checkout crash from a stack trace, identify the root cause, fix it, and add a regression test.
• Build Log Failure Diagnosis - Use a provided build log to explain why the build fails and identify the smallest verified fix path.

cli

• EXIF Rename CLI - Build a small CLI that renames photos by EXIF date and test it on a photos folder.

refactor

• Auth Dependency Injection Refactor - Refactor auth code to dependency injection while preserving tests, coverage, and public API.
• Split Oversized File - Split an oversized source file into focused modules while preserving behavior.

security-ops

• NPM Audit Clean Remediation - Patch npm audit vulnerabilities without breaking tests or public APIs.

performance

• Lighthouse And Core Web Vitals Gate - Improve Lighthouse and Core Web Vitals to explicit thresholds without regressions.
• Bundle Size Reduction - Iteratively reduce bundle size below the documented threshold.
• Benchmark Optimization - Optimize performance against a benchmark command until the goal is reached.
• Order Service Performance Review - Inspect service code for N+1 queries, missing indexes, inefficient loops, missing caches, and unnecessary fetching.
• Node Memory Leak Fix - Investigate a growing-memory Node.js process, isolate the leak source, fix it, and add monitoring for recurrence.
• GOAP API Latency Reduction - Reduce API latency by profiling current performance, optimizing database queries, adding caching, and improving code paths.

greenfield-build

• Build Design Tool From Scratch - Run a long-horizon Codex task to build a design tool with milestone verification.

product

• Design Doc Acceptance Complete - Implement a design document until every acceptance criterion is satisfied.
• Feature Flag System - Implement boolean, percentage, and user-based feature flags with service logic, API middleware, a React hook, docs, and tests.
• OKR Development From Vague Priorities - Turn vague strategic priorities into measurable OKRs with objectives, key results, alignment, scoring, guardrails, and a communication summary.

backlog

• Clear Labeled Issue Backlog - Work through a labeled issue queue until no matching issues remain.
• Clear Trading App Backlog - Generate a roadmap backlog for a trading app and then clear it with goals.
• Ship Backlog Features - Implement the feature list from BACKLOG.md until CI is green.

data-analytics

• Analyze Product Usage Patterns - Analyze product usage patterns between tab view and agent panels.

frontend

• Fix Freezing Chart Tooltips - Debug and fix chart tooltips that freeze on hover.
• Improve Common Error Messages - Use a cloud coding agent to implement user-friendly messages for common errors.
• Visual Feedback With Test Guard - Add correct and wrong answer visual feedback while keeping tests green.
• Theme Toggle Persistence - Add a dark and light theme toggle that persists across refreshes.
• Button Console Error Fix - Use browser automation to click a button, inspect console errors, fix the issue, and prove it.
• Next.js Chat History Sidebar - Replace a Next.js sidebar with chat history, then test, fix build issues, and push.

research

• Read-Only Font Match - Research font matches in read-only mode and produce a report without purchasing or downloading assets.
• Public Benchmark Table - Collect distinct public benchmarks and build a date-sorted comparison table.
• Review Sentiment JSON Agent - Fetch reviews with browser automation, classify sentiment, and write structured JSON output.

maintenance

• Repo Maintenance Audit - Find dead code, unused dependencies, and stale files, then produce a PR-ready justification list.
• Clean Worktree File Budget - Keep the worktree clean and enforce a source file size budget.

devops-ci

• CI Pipeline Green - Repair CI test, lint, typecheck, and security scan failures until checks pass.

goal-maintenance

• Goal Escape Hatch - Add an explicit incomplete state for impossible subtasks so a goal loop can stop safely.
• Goal-Forge Done-When Loop - Write a GOAL.md-style contract where done_when controls completion instead of vague success claims.
• Review Plan Until No Gaps - Loop on implementation-plan review until a fresh review finds no remaining gaps.
• Long Task Until Verification - Continue a long-running task until final verification passes rather than stopping on partial progress.
• Completion Audit Before Done - Audit completion criteria before calling the goal complete.
• Goal Permission Context Sync - Ensure goal continuation uses the current permission context after approval mode changes.
• Real CLI Goal Loop - Verify a real CLI goal loop where the second judge round confirms completion.
• Verify File Creation - Verify that a requested file was actually created instead of trusting the agent claim.
• Queue Follow-Up Goals - Promote queued follow-up goals: fix tests, run full tests, then produce coverage.
• Daily Goal Priority Loop - Use a persistent goal profile to compute daily priorities, execute them, log progress, and refresh status across sessions.
• Goal-Aligned Profile Optimization - Audit and update professional profiles against a stated goal while recording the resulting progress and gaps.
• Content And Audience Engagement Loop - Generate goal-aligned content, publish or promote it, engage with target audience posts, and log the session outcome.

qa

• QA Engineer Simulation - Use /goal as a quality loop until tests pass and lint is clean.

orchestration

• DAG Agent Dispatch - Split a goal into a dependency graph and dispatch independent agents into isolated worktrees.
• DAG-Aware Semantic Merge Repair - Make orchestration merge failures repairable by using plan DAG context, conflict bundles, planner-mediated repair, and bounded retry.
• Plan EventBus Live UX - Unify plan, fork, merge, and orchestrate around shared builders and a live plan event stream.

backend-api

• API Integration Tests - Add end-to-end tests for product API endpoints with success and error cases.
• User Preferences API - Add GET, PUT, and PATCH endpoints for user preferences with validation, service logic, OpenAPI docs, and tests.
• SPARC Payment Processing Plan - Plan and implement payment processing through SPARC phases with requirements, pseudocode, architecture, TDD refinement, and integration.

backend-data

• Dev Database Migration Proof - Write a migration, run it against the dev database, and confirm the schema matches.
• Slow Query Optimization Report - Analyze slow query logs, explain bottlenecks, recommend indexes or rewrites, and produce prioritized SQL changes.

accessibility

• HTML WCAG Instruction Audit - Audit HTML changes against WCAG guidance and prove the Lighthouse accessibility audit passes.

design

• Reference Layout Match - Build a settings page that follows an existing profile page layout instead of inventing a new pattern.

mobile

• Mobile Agent Task Handoff - Prepare and track a coding-agent task started from GitHub Mobile with review-ready evidence.

ai-evals

• Trace-Graded Agent Regression - Create trace-based evals that catch workflow regressions across tool calls and handoffs.

ai-ops

• Agent Trace Observability - Instrument agent runs so LLM generations, tool calls, handoffs, guardrails, and custom events are traceable.

data-eng

• CSV Processing Report - Create a data processing script that validates CSV input and generates an analysis report.
• Rate-Limited Web Scraper - Build a scraper that extracts product data across paginated pages while respecting rate limits and logging progress.

devops-runtime

• Remote Agent Server Smoke - Deploy an isolated remote agent server and prove event streaming, workspace access, and command execution work.

security-appsec

• Tool Guardrails For AppSec - Add tool guardrails around high-risk agent tool calls and stop unsafe input or output before execution continues.
• Security PR Review - Review a pull request for input validation, authentication, injection, XSS, and secrets risks with file-level fixes.

How To Write A Good Goal

Start with the tutorial: How To Write A Good /goal.

The short version: write one measurable goal, point at the real context, add hard constraints, define DONE WHEN, require fresh verification, and give the agent explicit stop rules for uncertainty or risk.

Catalog Health

The generated catalog health report tracks source-backed coverage, source types, and search evaluation results.

Templates

• Full template for high-risk or multi-step work.
• Compact template for routine work.
• Structured JSON data for search, tooling, or site generation.
• Start-here recipes for common user entry points.
• Data schema for provenance fields and source types.

Quality Bar

• One example should cover one measurable goal.
• The prompt must include verification that can run in a real repository or produce a concrete artifact.
• New externally sourced examples must include source_name, source_url, source_type, evidence, and generated evidence_summary in data/examples.json.
• Do not add undocumented slash-command behavior, fake tool capabilities, or examples copied from private/non-verifiable sources.

Sources And Caveats

See SOURCES.md for public sources used by source-backed examples and notes about cross-tool differences.

This repository does not claim that /goal behaves identically across Codex, Claude Code, Hermes, or other tools.

Contributing

Read CONTRIBUTING.md before adding examples. Keep descriptions short, source-backed when based on external material, and scoped to verifiable engineering work.