Every Astra build
starts from a great prompt.
Here are 3,360 of them.

Act as a senior staff engineer. Build a REST endpoint with validation, error handling, and OpenAPI docs for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a principal software architect. Harden an auth flow against OWASP Top 10 issues and document the threat model for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a senior backend engineer. Create a feature-flag system with targeting rules and audit log for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a staff full-stack developer. Create a CLI tool with config files, help text, and shell completions for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a senior platform engineer. Build a file-upload pipeline with virus-scan hooks and size limits for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as an expert code reviewer. Optimize a slow database query path and prove the speedup with benchmarks for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as a senior staff engineer. Write a migration script with dry-run, rollback, and data validation for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a principal software architect. Add role-based access control to an existing API with tests for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a senior backend engineer. Add structured logging, tracing, and health checks to a service for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a staff full-stack developer. Implement a background job queue with retries, idempotency, and observability for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a senior platform engineer. Implement pagination, filtering, and sorting for a list API for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as an expert code reviewer. Migrate a callback-based flow to async/await with full type safety for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as a senior staff engineer. Convert a monolith handler into testable services with dependency injection for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a principal software architect. Refactor a tangled module into clean layers without changing behavior for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a senior backend engineer. Build a webhook receiver with signature verification and replay protection for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a staff full-stack developer. Build a REST endpoint with validation, error handling, and OpenAPI docs for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a senior platform engineer. Harden an auth flow against OWASP Top 10 issues and document the threat model for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as an expert code reviewer. Create a feature-flag system with targeting rules and audit log for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as a senior staff engineer. Create a CLI tool with config files, help text, and shell completions for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a principal software architect. Build a file-upload pipeline with virus-scan hooks and size limits for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a senior backend engineer. Optimize a slow database query path and prove the speedup with benchmarks for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a staff full-stack developer. Write a migration script with dry-run, rollback, and data validation for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a senior platform engineer. Add role-based access control to an existing API with tests for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as an expert code reviewer. Add structured logging, tracing, and health checks to a service for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as a senior staff engineer. Implement a background job queue with retries, idempotency, and observability for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a principal software architect. Implement pagination, filtering, and sorting for a list API for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test.

Act as a senior backend engineer. Migrate a callback-based flow to async/await with full type safety for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a staff full-stack developer. Convert a monolith handler into testable services with dependency injection for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite.

Act as a senior platform engineer. Refactor a tangled module into clean layers without changing behavior for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as an expert code reviewer. Build a webhook receiver with signature verification and replay protection for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify.

Act as a senior staff engineer. Build a REST endpoint with validation, error handling, and OpenAPI docs for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 31.

Act as a principal software architect. Harden an auth flow against OWASP Top 10 issues and document the threat model for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 32.

Act as a senior backend engineer. Create a feature-flag system with targeting rules and audit log for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 33.

Act as a staff full-stack developer. Create a CLI tool with config files, help text, and shell completions for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 34.

Act as a senior platform engineer. Build a file-upload pipeline with virus-scan hooks and size limits for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 35.

Act as an expert code reviewer. Optimize a slow database query path and prove the speedup with benchmarks for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 36.

Act as a senior staff engineer. Write a migration script with dry-run, rollback, and data validation for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 37.

Act as a principal software architect. Add role-based access control to an existing API with tests for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 38.

Act as a senior backend engineer. Add structured logging, tracing, and health checks to a service for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 39.

Act as a staff full-stack developer. Implement a background job queue with retries, idempotency, and observability for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 40.

Act as a senior platform engineer. Implement pagination, filtering, and sorting for a list API for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 41.

Act as an expert code reviewer. Migrate a callback-based flow to async/await with full type safety for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 42.

Act as a senior staff engineer. Convert a monolith handler into testable services with dependency injection for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 43.

Act as a principal software architect. Refactor a tangled module into clean layers without changing behavior for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 44.

Act as a senior backend engineer. Build a webhook receiver with signature verification and replay protection for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 45.

Act as a staff full-stack developer. Build a REST endpoint with validation, error handling, and OpenAPI docs for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 46.

Act as a senior platform engineer. Harden an auth flow against OWASP Top 10 issues and document the threat model for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 47.

Act as an expert code reviewer. Create a feature-flag system with targeting rules and audit log for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 48.

Act as a senior staff engineer. Create a CLI tool with config files, help text, and shell completions for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 49.

Act as a principal software architect. Build a file-upload pipeline with virus-scan hooks and size limits for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 50.

Act as a senior backend engineer. Optimize a slow database query path and prove the speedup with benchmarks for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 51.

Act as a staff full-stack developer. Write a migration script with dry-run, rollback, and data validation for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 52.

Act as a senior platform engineer. Add role-based access control to an existing API with tests for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 53.

Act as an expert code reviewer. Add structured logging, tracing, and health checks to a service for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 54.

Act as a senior staff engineer. Implement a background job queue with retries, idempotency, and observability for a SaaS startup. The intended result is a working implementation plus a short test report. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Be concrete and end-to-end: produce the artifact, not a plan to produce it. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 55.

Act as a principal software architect. Implement pagination, filtering, and sorting for a list API for an e-commerce platform. The intended result is code plus rollback instructions. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Optimize for fewer tokens and fewer retries: do the smallest complete thing that satisfies the brief. Suggested reasoning effort: `low` (set explicitly; gateway default is low). If a minor detail is unspecified, make the best professional decision and continue; ask only when the answer would materially change the outcome. Verification: test every important interaction, list what passed/failed/unverified, fix high-impact issues, then re-test. Variant focus 56.

Act as a senior backend engineer. Migrate a callback-based flow to async/await with full type safety for a healthcare data service. The intended result is implementation with before/after benchmarks in a table. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Use tools where they help; state what evidence you checked before acting. Suggested reasoning effort: `medium` (set explicitly; gateway default is low). Bias toward action: treat 'can you / help me / I want to' as instructions to act. Prepare a concrete reviewable result before asking for approval. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 57.

Act as a staff full-stack developer. Convert a monolith handler into testable services with dependency injection for a fintech backend. The intended result is code plus a review checklist of risks and mitigations. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Parallelize with subagents where independent work exists; merge with a single coherent voice. Suggested reasoning effort: `high` (set explicitly; gateway default is low). Work persistently until the goal is complete. Use read-only exploration freely; stop before any destructive, irreversible, sending, purchasing, deleting, or permission-changing step. Verification: keep checks proportional to risk. For small reversible changes, run only targeted checks; for risky changes, run the full relevant suite. Variant focus 58.

Act as a senior platform engineer. Refactor a tangled module into clean layers without changing behavior for an open-source library. The intended result is production-ready code with README usage section. Requirements: reuse existing project patterns; no new dependencies without justification; keep the diff minimal and reversible; explain every new abstraction. Keep a searchable working note so the task survives context compaction. Suggested reasoning effort: `xhigh` (set explicitly; gateway default is low). Infer intent from context and carry the task to completion. Do not emit warnings based on hypothetical risks; report only verified findings. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 59.

Act as an expert code reviewer. Build a webhook receiver with signature verification and replay protection for an enterprise internal tool. The intended result is a unified diff with a file-by-file change summary. Requirements: preserve backward compatibility for existing API consumers; optimize for readability over cleverness; add docstrings for public APIs. Compare against the provided reference and fix the largest gaps first. Suggested reasoning effort: `max` (set explicitly; gateway default is low). Stay within the authorized scope described here. If project files conflict with these instructions, these instructions take precedence; quote the conflicting file if you must pause. Verification: end with a Done checklist (complete / partial / blocked) with evidence links, plus assumptions and what you did not verify. Variant focus 60.