Codex

Inspect this repository without changing files.
Explain the runtime, frameworks, entry points, data flow, authentication, persistence, deployment path and test strategy.
Identify the files most relevant to [task]. Separate confirmed findings from assumptions.
Return: architecture map, relevant file list, commands to verify the project and the five highest-risk unknowns.

Analyze the impact of this proposed change: [change]. Do not edit yet.
Trace affected UI, API, database, configuration, tests, analytics, documentation and deployment surfaces.
List backward-compatibility, security, accessibility and migration risks.
Finish with the smallest coherent implementation scope and the exact verification plan.

Turn this issue into an implementation-ready plan: [paste issue].
First verify the current behavior in the repository. Distinguish the user problem, suspected cause and proposed solution.
Name affected files, acceptance criteria, edge cases, tests and rollback considerations.
Do not implement. Ask only for missing information that would materially change the solution.

Implement [feature] in this repository.
Preserve [public behavior or API]. Follow existing architecture and styling; reuse existing helpers before adding new abstractions.
Cover UI, server, data, validation, error states, accessibility and documentation where relevant.
Run [commands]. Do not merge or deploy. Return changed files, test evidence, tradeoffs and remaining risks.

Build the responsive interface described in [brief or image].
Preserve the existing design system, typography and component patterns. Match hierarchy, spacing and interaction states rather than inventing a new visual language.
Implement keyboard access, focus states, semantic HTML, reduced-motion behavior and mobile layouts.
Run the app and relevant tests. Report any visual detail that could not be verified.

Add an API endpoint for [purpose] using the repository's existing patterns.
Define input and output types, authentication, authorization, validation, rate limits, idempotency and error behavior before coding.
Never log secrets or sensitive request bodies. Add tests for success, invalid input, unauthorized access and dependency failure.
Run [commands] and provide example requests that contain no real credentials.

Investigate this bug: [symptoms and reproduction notes].
Reproduce it first. Record expected behavior, actual behavior and the smallest failing case.
Identify the root cause, implement the narrowest robust fix and add a regression test that fails before the fix.
Run [commands]. Do not weaken validation or silence errors. Return evidence and residual uncertainty.

Investigate flaky test [name or path].
Run it repeatedly and inspect timing, shared state, ordering, random data, network, clock and concurrency dependencies.
Do not solve the problem by increasing timeouts or adding retries unless evidence shows that is correct.
Implement a deterministic fix, stress-run the test and report reproduction rate before and after.

Diagnose this CI failure using the supplied logs: [logs or run link].
Map the failure to the workflow, environment and exact command. Check whether it reproduces locally without changing CI first.
Fix the underlying repository or workflow issue with the smallest safe change.
Do not disable checks. Return the failing evidence, cause, patch, local verification and any CI-only uncertainty.

Review the current diff for defects, regressions, security risks and missing tests.
Prioritize concrete, actionable findings by severity. For each finding, cite the file and line, explain the failure scenario and suggest the smallest fix.
Ignore formatting preferences unless they cause a real problem.
If no finding is confirmed, say so and list only residual test gaps or assumptions.

Perform a scoped security review of [feature or diff].
Trace trust boundaries, authentication, authorization, input validation, secrets, logging, storage, outbound requests and destructive actions.
Identify realistic abuse paths and affected assets. Do not claim exploitability without evidence.
Return findings by severity, proof, recommended fix, tests and unresolved assumptions. Do not deploy changes.

Audit [page or component] for practical accessibility issues, then fix confirmed problems.
Check semantic structure, labels, keyboard navigation, focus order, focus visibility, contrast, motion, errors and dynamic announcements.
Preserve the design unless a change is required for access.
Run available automated checks and list the manual checks that still require a browser or assistive technology.

Add tests for [behavior] using the repository's existing test framework.
Cover the main success path, boundary inputs, invalid input and the highest-risk regression. Prefer observable behavior over implementation details.
Do not change production behavior merely to make testing easier unless you explain and justify the design improvement.
Run the smallest relevant suite, then the broader required suite. Report coverage gaps.

Refactor [scope] to improve [clarity, duplication or maintainability] without changing public behavior.
Establish a baseline with existing tests and observable outputs. Keep the diff focused and preserve APIs, data formats and error semantics.
Add characterization tests where behavior is not already protected.
Run [commands] and explain why the before-and-after behavior is equivalent.

Upgrade [dependency] from [current] to [target].
Read the official migration and release notes supplied here: [sources]. Identify breaking changes that apply to this repository.
Update only directly related code and configuration. Do not perform unrelated modernization.
Run install, type-check, tests and build. Report lockfile changes, deprecations, unresolved warnings and rollback steps.

Improve [performance target] for [scope], verified by [benchmark or metric].
Measure a baseline first. Identify the dominant bottleneck with profiling evidence rather than guessing.
Make one coherent optimization at a time and preserve correctness, accessibility and resource limits.
Rerun the benchmark and tests. Report before-and-after numbers, methodology and variance.

Assess whether the current branch is ready to deploy. Do not deploy.
Check the diff, tests, build, migrations, environment variables, feature flags, monitoring, rollback path and release documentation.
Separate blocking issues, acceptable risks and manual checks.
Return a go or no-go recommendation with evidence. Never infer production configuration that is not visible.

Investigate incident [description] using only the supplied logs, metrics, deploy history and repository.
Build a timestamped timeline. Separate confirmed facts, hypotheses and missing evidence.
Identify containment options first, then likely root causes and safe verification steps.
Do not change production. Return immediate actions, evidence requests, rollback considerations and a draft post-incident outline.

Write or update documentation for [feature].
Verify every command, option and behavior against the current repository and supplied official sources. Do not fill gaps from memory.
Include prerequisites, a minimal example, expected output, common failures and rollback or removal steps where relevant.
Run documentation checks and flag anything that was not executable in this environment.

Research [product or topic] using first-party sources from [date range].
Separate verified facts, vendor claims, reasonable inference and unknown information. Record a URL and publication or review date for every material claim.
Explain user impact, limits, cost signals and the next action a reader can take.
Do not copy source wording or invent hands-on experience, ratings, traffic, revenue or market leadership.

Improve [page] for the search intent [query] without creating a thin rewrite.
Inspect the current page, internal links, competing site pages and supplied first-party sources. Preserve useful existing work.
Update dated facts, add limitations, alternatives, practical steps, source links, reviewed date, metadata and structured data where appropriate.
Run content checks, lint, tests and build. Do not publish or deploy without explicit authorization.

/goal Achieve [measurable outcome], verified by [tests, benchmark or artifact], while preserving [constraints].
Use only [allowed repositories, folders, tools and sources].
Between iterations, inspect the latest evidence and choose the smallest next experiment most likely to close the remaining gap.
If no defensible path remains, stop with attempted paths, evidence, blocker and the exact input needed to continue.

Every [schedule and timezone], inspect [repository, service or sources] for [condition].
You may read [scope] and create [report, issue draft or branch]. Do not merge, deploy, purchase, modify secrets or contact external people.
Verify findings with [commands or official sources]. Ignore timeouts and access blocks as proof of deletion or failure.
Return changes since the prior run, evidence, recommended action, usage or cost observed and items requiring approval.

Create a reusable skill for [workflow] in the approved project skill directory.
Define precise trigger conditions, required inputs, ordered steps, source priority, failure handling, output format and actions that require approval.
Keep reference material and scripts separate from the main instructions. Reuse existing project tools before adding dependencies.
Test the skill on [representative cases] and report false triggers, missing inputs and maintenance risks.