Give your next build a better brief.

Keep action mappings, displayed instructions, and persistent settings aligned.

Find editor-only assumptions before they become missing assets for players.

Make loading, audio, resize, focus, and saved progress behave deliberately.

Create a complete move, collect, finish, and restart loop before expanding the world.

Exercise a small shared flow under delay, loss, and reconnection conditions.

Compare the same encounter before and after a measured correction.

Define persistent facts, stable identities, compatibility, and a fresh-launch check.

Make the accepted game rule explicit before adding immediate local feedback.

Specify simultaneous fingers, cancellation, and interruption before polishing gestures.

Find the cost that appears during real play rather than optimizing from a cool-device snapshot.

Compare graphics and sound costs while preserving essential feedback.

Turn platform-specific requirements into a concrete target-hardware review.

Define what remains usable and how stale or absent content is presented.

Follow one record through the interface, server, storage, and reload.

Implement a usable form with a preserved draft, useful validation, and keyboard behavior.

Locate the failing stage before changing handlers or infrastructure.

Trace identity, permission, input, storage, and response as one server operation.

Use measurements to decide whether a worker improves a specific interaction.

Check compatibility and data meaning before releasing connected changes.

Find layout and interaction failures that polished sample data can hide.

Make success, errors, permissions, retries, and examples explicit.

Check the consumer contract when a service is slow, unavailable, or returns unexpected data.

Find where an interface recreation or process loss can discard user progress.

Keep screen state and durable records separate while handling recreation.

Preserve a useful draft through departure and return while respecting platform conventions.

Compare complete journeys across targets without requiring identical interfaces.

Plan local durability, pending state, retries, and conflict resolution together.

Define a shared contract with separate verified platform implementations.

Follow a record through local storage, queued work, network acknowledgement, and reconciliation.

Check consent, capability configuration, lifecycle, and user-visible recovery.

Specify arguments, streams, exit codes, and safe file behavior.

Verify installation and real file workflows beyond the development folder.

Expose a specific desktop operation with validated messages and defined errors.

Build open, edit, save, close, and recovery behavior as one journey.

Make the command’s target, effects, collisions, and reversibility inspectable.

Inspect how a rendered page reaches privileged functionality.

A focused prompt for data analysis with explicit scope, realistic failure cases, and verification.

A focused prompt for data engineering with explicit scope, realistic failure cases, and verification.

A focused prompt for database engineering with explicit scope, realistic failure cases, and verification.

A focused prompt for model evaluation with explicit scope, realistic failure cases, and verification.

A focused prompt for machine learning with explicit scope, realistic failure cases, and verification.

A focused prompt for ai applications with explicit scope, realistic failure cases, and verification.

A focused prompt for scripting with explicit scope, realistic failure cases, and verification.

A focused prompt for workflow automation with explicit scope, realistic failure cases, and verification.

A focused prompt for systems programming with explicit scope, realistic failure cases, and verification.

A focused prompt for concurrency with explicit scope, realistic failure cases, and verification.

A focused prompt for network programming with explicit scope, realistic failure cases, and verification.

A focused prompt for containers with explicit scope, realistic failure cases, and verification.

A focused prompt for reliability and observability with explicit scope, realistic failure cases, and verification.

A focused prompt for cloud infrastructure with explicit scope, realistic failure cases, and verification.

A focused prompt for identity and access with explicit scope, realistic failure cases, and verification.

A focused prompt for secure delivery with explicit scope, realistic failure cases, and verification.

A focused prompt for application security with explicit scope, realistic failure cases, and verification.

A focused prompt for internet of things with explicit scope, realistic failure cases, and verification.

A focused prompt for microcontrollers with explicit scope, realistic failure cases, and verification.

A focused prompt for robotics and simulation with explicit scope, realistic failure cases, and verification.

A focused prompt for scientific simulation with explicit scope, realistic failure cases, and verification.

A focused prompt for numerical computing with explicit scope, realistic failure cases, and verification.

Describe current behavior, the desired change, and the scenarios that establish success.

Separate path discovery from mutation, reject conflicts, and account for changes between planning and execution.

Collect enough evidence to reproduce a bug without copying an environment or private payload wholesale.

Find the difference between an attractive demo and a working user journey.

Remove accumulated friction while preserving real project boundaries.

Review supported, missing, and conflicting evidence without substituting confidence for verification.

Check whether a grader follows evidence and rubric anchors rather than length or response position.

Keep a drag’s accepted result separate from its temporary preview and interruption cleanup.

Keep fast-changing input attached to the latest accepted job, even when cancellation is incomplete.

Avoid invented imports and unnecessary package upgrades.

Audit parsed values against a supplied synthetic order policy and source evidence.

Compare two viable approaches against your experience, hosting needs, and maintenance priorities.

Connect a service with appropriate credentials, error handling, and an integration check.

Treat a convenient file picker as the start of a validated workflow.

Carry current decisions, verified work, and the next task into a fresh session.

Compare a reusable prompt against consistent realistic cases.

Build correct positive and near-miss examples for a specific validation policy.

Make storage, ownership, editing, deletion, and recovery explicit.

Prepare separate development and final cases from the task requirements.

Compare a baseline and a single removal with stable cases and observable criteria.

Measure your own tasks without claiming a universal AI speedup.

Test the outcomes and failure modes that matter, using the existing project setup.

Measure the slow action, address the observed bottleneck, and compare the same scenario.

Understand a command's scope before running it.

Make defaults, files, environment overrides, and command arguments observable through safe provenance.

Choose a transaction boundary and prove the export is internally consistent with a controlled second writer.

Make essential state and actions available beyond drawn pixels.

Bound the replay target and compare accepted simulation state instead of trusting a shared seed.

Give your assistant the reproduction, expected result, actual result, and relevant evidence.

Connect a real interface action to server checks, stored data, and confirmed results.

Use an appropriate interaction pattern and keep focus distinct from selection.

Define decoding, dialect, and rejected-record behavior before turning an unfamiliar export into data.

Check keyboard access, focus, semantics, labels, and feedback in the main user journey.

Turn specific design observations into responsive, accessible interface changes.

Turn an explanation into small checks you can reason about.

Trace an example through inputs, decisions, outputs, and side effects, then try a small exercise.

Separate signature checks, durable receipt, pending work, and completed effects for a webhook handler.

Connect player intent to the actual audio-state outcome rather than an optimistic icon.

Ask for an evidence-based feature inventory before choosing the next improvement.

Create a deliberate comparison key without silently rewriting display text or merging distinct records.

Turn a save-format change into explicit conversions, fixtures, and a recoverable failure path.

Investigate a repository through specific questions instead of loading unrelated code.

Check required behavior, configuration, database changes, and a practical recovery procedure.

Connect a prompt revision to its rendering inputs, evaluation evidence, and rollback choice.

Make the implementation's proof and remaining gaps easy to inspect.

Specify numeric representation, conversion, and rounding as part of the data contract.

Keep document content separate from the agent's actual task instructions.

Treat a table-copy migration as a schema-and-data change with a documented recovery rehearsal.

Separate camera and decorative motion from the information players need to act.

Clarify a module’s responsibilities while preserving its behavior and public interface.

Check old and new application behavior before removing data or tightening a constraint.

Separate deterministic replay fixtures from statistical evidence and from physical hardware claims.

Define ownership, versions, and the merge decision before adding retry logic.

Separate draft recovery, transient screen state, and accepted stored records.

Test the complete keyboard journey even when the original trigger disappears.

Reconcile a handoff with the actual repository before continuing.

Keep a durable job checkpoint separate from a live database cursor or connection.

Plan for existing records, deployed code, migration verification, and recovery.

Check real access rules with anonymous, owner, and second-account scenarios.

Find actionable bugs and regressions with concrete triggers, impacts, and file references.

Ask for reproducible findings without letting a completion summary define success.

Test layout direction, embedded phrases, and locale formatting as separate requirements.

Find supported requirement violations and stop after a focused revision check.

Separate when notes should sound from when the interface happens to redraw.

Make a named time zone, daylight-saving policy, and duplicate-run identity part of the schedule contract.

Make source evidence, missing dates, and non-task inputs explicit before choosing a schema.

Capture a short-lived player intention and consume it once when a legal action becomes possible.

Replace another guess with a diagnostic based on the current code and observed failure.

Check decoder state and record boundaries before adding checkpoints to a large-file transform.

Define a total order and a live-versus-snapshot policy before claiming complete traversal.

Turn a product idea into a concrete build request with a user journey and evidence of completion.

Define the user, core journey, smallest useful feature set, and observable acceptance criteria.

Map the real files, data flow, local setup, and verification workflow before changing code.

Measure the need, then preserve focus, selection, row context, and an accessible fallback.

Translate a vague feature request into behaviors you can check.