Focused instructions with clear triggers, concrete outputs, and inspectable source. Start small; validate in your own environment.
Turn an engineering request into a bounded work packet with owned paths, dependencies, acceptance criteria, verification commands, and a handoff contract. Use before delegating non-trivial repository work.
Prepare a commit-specific engineering handoff from an existing Git worktree, separating actual changes and executed checks from unresolved work, resource ownership, and integration risks.
Select relevant project-owned checks for an observed change and produce an evidence-based verification report that distinguishes passed, failed, skipped, blocked, and not-run checks.
Investigate a reproducible software failure by separating observations from explanations, testing competing hypotheses, and verifying a minimal repair against the original failure.
Turn a feature or bug contract into focused tests with explicit input partitions, observable outcomes, boundary cases, and evidence that the tests detect the behavior they are meant to protect.
Review a rendered web interaction for usability, responsive layout, keyboard behavior, state handling, and implementation defects, producing reproducible findings rather than a generic design checklist.
Qualify a repository for native TypeScript 7 with a compatibility matrix, separate compiler-API consumers, diagnostic parity, measured performance, and reversible adoption.
Design domain types and runtime input boundaries that distinguish legal states, optional values, and exhaustive transitions without unsafe assertions.
Build ESM package boundaries against real Node/browser consumers, export maps, declaration files, and initialization behavior instead of workspace-only imports.
Compose native compiler diagnostics, formatting, linting, type-aware analysis, and runtime tests as distinct checks with precise task inputs and actual evidence.
Implement cohesive Go packages with thin transports, explicit dependency and transaction ownership, and shared application policy across API, CLI, and MCP entry points.
Implement bounded Go concurrency with clear goroutine lifetimes, cancellation, backpressure, channel ownership, and verified shutdown/error behavior.
Design Go tests with independent assertions, controlled in-process timing, bounded fuzz/race checks, and isolated real dependencies for persistence and network semantics.
Investigate Go latency, CPU, allocation, and contention bottlenecks using representative profiles, controlled benchmarks, and correctness-preserving changes.
Evolve OpenAPI contracts against an accepted consumer baseline with explicit wire semantics, compatibility analysis, migration decisions, and runtime checks.
Keep generated Go and TypeScript clients, validators, and queries aligned with canonical inputs using pinned generation, reproducible output, and real consumer/wire tests.
Implement database invariants with explicit transaction ownership, isolation decisions, constraint-backed concurrency control, and retry-safe effects.
Test schema changes against populated prior versions, rolling application compatibility, locks/backfills, and explicit recovery rather than clean-install success alone.
Evolve deterministic orchestration using representative history replay, version-qualified SDK behavior, and separate tests for external activity effects.
Design retryable effects with stable business identities, bounded timeouts, durable reconciliation, and tests for success before acknowledgment failure.
Qualify worker upgrades against self-hosted prerequisites, actual execution routing, replay evidence, external compatibility, and safe version drainage.
Use current project/task graphs and semantic navigation to map impact, enforce important boundaries, and validate derived configuration without duplicating existing tooling.
Verify cache reuse with controlled input mutations and fresh reference execution, including generated and ignored outputs, environment, and toolchain changes.
Review producer/consumer cache authority, scoped credentials, sensitive output, nonproduction denial tests, and recovery from suspect artifacts.
Manage parallel lanes with separate source, mutable output, port, database, queue, process, lease, and recoverable cleanup ownership.
Assemble task-sized context from current canonical source, accepted contracts, graphs, and semantic tools while tracking freshness and missing information.
Compare actual compiler, runtime, package-manager, container, and agent-tool identities across environments and verify targeted drift corrections.
Distinguish file synchronization, restart, recompilation, image rebuild, and platform validation in a container loop that preserves owned application state.
Validate combined parallel changes and promote identified artifacts while preserving independent release approval, integration capacity, and recovery.
Design thin MCP adapters with bounded schemas, trusted application identity, shared authorization, and explicit effects rather than treating instructions as permissions.
Integrate providers through capability-aware contracts, normalized outcomes, bounded retries, authenticated callbacks, and explicit reconciliation/cancellation differences.
Enforce tenant-scoped operations across transports, jobs, data, and caches using trusted identity and independent cross-tenant denial tests.
Account for usage through stable event identities, explicit precision and settlement policy, duplicate protection, adjustments, and replayable reconciliation.
Model durable jobs with legal transition authority, stable operation/attempt identity, guarded effects, cancellation races, and recoverable indeterminate outcomes.
Track immutable asset identities and derivation operations with versioned metadata, integrity checks, and explicit access, privacy, and retention boundaries.
Select canonical public skills and bind private repository context separately without copying instructions, silently installing packages, or broadening tool authority.
Turn a broad engineering goal into independently reviewable outcomes, explicit uncertainty, dependency edges, and a bounded first execution wave.
Build an expiring capability inventory from actual worker and tool probes while separating advertised, observed, unavailable, and authorized operations.
Match ready tasks to qualified workers using required capabilities, phase, effect policy, availability, and measured tradeoffs without hardcoding provider superiority.
Select genuinely ready parallel work without colliding on shared files, mutable resources, unstable contracts, or review capacity.
Give a delegated worker a bounded goal, accepted source identity, explicit tools/effects, resource limits, check requirements, and a result envelope.
Track allocated, running, submitted, accepted, failed, and indeterminate work with explicit ownership and recoverable interruption.
Resume interrupted coordination from checked run records, reusing only current accepted artifacts and withholding ambiguous or stale work.
Classify agent failures, preserve evidence, and choose bounded retries or reconciliation without repeating costly or unsafe effects.
Accept worker results against independent contracts and integrate combined changes without treating individual green branches as release evidence.
Capture task/attempt traces that explain delegation, queue time, context identity, resource pressure, and whether submitted work was actually integrated.
Reduce child-agent authority to the intersection of parent authority, task needs, organization policy, and currently approved effects.
Place approvals at consequential effect boundaries and bind them to exact scope, inputs, identity, expiry, and execution policy.
Reserve and reconcile agent, token, tool, and effect budgets without converting missing usage into free execution or silently switching billing paths.
Budget model workers separately from CPU, memory, database, browser, and build resources while reserving capacity for acceptance and integration.
Detect repeated no-progress tool calls, equivalent patches, and unchanged failures using bounded evidence windows and explicit stop/escalation criteria.
Evaluate whether delegation improves accepted task outcomes using matched inputs, independent checks, repeated sessions, and explicit handoff/integration scoring.
Allocate task context by relevance and authority while preserving accepted constraints, high-value code, unresolved failures, and recoverable references.
Preserve task state across compaction or handoff with source-backed decisions, unresolved failures, current artifacts, and explicit freshness checks.
Select a source-specific read, search, feed, or transcript path without confusing URL recognition, configured tools, and actual authorized access.
Diagnose each source operation using separate installation, execution, connectivity, authentication, permission, and live-result evidence.
Read an explicitly authorized public page into a bounded, source-linked, untrusted evidence packet without executing its content or crossing private-network boundaries.
Compare feed snapshots by stable item identity and content while distinguishing updates, window expiry, pagination, and malformed or incomplete captures.
Turn authorized caption files into timestamped evidence with declared language/origin and clear separation between speech, descriptions, and visual content.
Use private or logged-in source connectors with verified identity, narrow operations, explicit data recipients, and access-aware fallback decisions.
Build a claim-oriented research record from independent primary sources, bounded discovery, exact revisions, and explicit disagreements or access gaps.
Review connector installation and upgrade plans for exact provenance, scoped mutations, credential exposure, operation tests, and recoverable removal.
Assign browser contexts and account state to explicit agent lanes, verify readiness and isolation, and preserve evidence before releasing only owned resources.
Compare an intended agent execution profile with current worktree-bound observations, separating requested settings, resolved configuration, and actual runtime behavior.
Qualify one controller-to-agent execution interface for lifecycle, event identity, cancellation, authentication, and uncertain outcomes before admitting real tasks.
Reconcile full task identity, accepted prerequisites, source contracts, and ownership immediately before dispatch without treating labels or filtered queries as acceptance.
Test a selected controller against deterministic readiness, restart, cancellation, retention, stale-attempt, and independent-acceptance scenarios before deployment.
Normalize runtime event captures with explicit identity, usage basis, duplicate handling, missing coverage and independent acceptance boundaries.
Author and qualify scoped structural transformations with positive and negative examples, reviewed diffs, repeat-application checks, and independent runtime/type validation.
Extract records against an independent field contract, rejecting decoy matches, wrong cardinality, and unsupported adaptive recovery while preserving source evidence.
Specify finite, authorized multi-page collection with persistent cooldowns, deduplication, freshness and recovery rules, without treating a plan as an executing crawler.
Qualify a specific third-party MCP server revision through identity, effect review and actual protocol/operation evidence rather than treating discovery as approval.
Evaluate one harness change with a fixed workload, explicit limits, all-attempt accounting, independent integration evidence, and a review decision that preserves unfinished work.
Investigate developments in an explicit time window using dated source captures, event-level deduplication, independent evidence and visible coverage gaps.
Produce evidence-linked technical-debt findings with consequences, deliberate tradeoffs, bounded repair targets and independent reproduction checks rather than a style-driven rewrite list.
Explain an inspected system or change with source-linked relationships, explicit assumptions, readable visual structure and an equivalent accessible narrative.
Plan a product video as a timed shot, asset, claim and caption contract before authorizing generation, composition or publication.
Qualify a bounded media transformation using input identity, installed capabilities, independent output properties and decode evidence without treating process exit as delivery acceptance.
Audit a static publication for canonical URL, metadata, sitemap, internal-link and indexing-directive mistakes while separating technical findings from search ranking claims.
Design React components around stable identity, explicit ownership and composable behavior; preserve focus and local state while making feature boundaries easier to change.
Identify the actual cause of slow React interactions and reduce unnecessary work using measured state boundaries, subscriptions, scheduling and justified memoization.
Assign each UI value one authoritative owner across local state, URL state, form drafts, server caches and shared client stores, with explicit reconciliation rules.
Implement React Query data access with complete query identities, explicit freshness, cancellation, mutation reconciliation and isolated server-rendering caches.
Plan App Router features around route ownership, server/client execution, loading and failure boundaries, cache semantics and the actual deployment target.
Keep server-only data and execution out of client graphs while composing small interactive React islands with explicit serialization and hydration contracts.
Build maintainable utility-based interfaces with version-correct tokens, statically discoverable variants, responsive behavior and tested component composition.
Establish a small versioned system of semantic tokens, accessible primitives and feature compositions with clear ownership and migration criteria.
Implement layouts that adapt to container space, content length, input mode and zoom without hiding required actions or masking overflow.
Implement and verify accessible frontend interactions through native semantics, meaningful names, keyboard/focus behavior and explicit assistive-technology limits.
Build React forms with a deliberate native or React Hook Form lifecycle, accessible errors, stable field identity and authoritative server validation.
Use a validated URL as the authority for shareable frontend state while preserving browser history, unrelated parameters and safe navigation boundaries.
Convert untrusted transport data into deliberate frontend view models without leaking service details, precision errors or unauthorized fields throughout the component tree.
Design initial, empty, refreshing, partially failed and mutation-pending UI states that preserve useful data and offer safe, attributable recovery.
Persist frontend state only under explicit privacy, schema, quota and reconciliation policies; distinguish local durability from synchronized server acceptance.
Move suitable CPU-heavy work away from urgent UI interactions while controlling worker ownership, message identity, cancellation and stale results.
Set and evaluate route-specific frontend budgets for transfer size, main-thread work and user-visible loading without equating synthetic checks with field performance.
Choose unit, component and browser checks around user-visible frontend contracts, with independent network fixtures and explicit integration coverage.
Use reproducible visual evidence to detect frontend regressions while preserving independent interaction, accessibility and content checks.
Keep untrusted content, navigation, credentials and server effects behind explicit boundaries while testing the real browser-to-server trust model.
Use motion to explain interaction and hierarchy while preserving reduced-motion alternatives, interruption behavior and rendering performance.
Restructure React components, hooks and data flow while preserving user-visible behavior, state lifetime, focus and effect ownership.
Select and integrate a coherent icon family using React Icons, Lucide or an existing library with accessible meaning, bounded imports and preserved upstream license information.
Turn a frontend task into a coherent, testable interface direction grounded in the audience, product workflow, existing system and realistic content states.
Compose installed headless primitives and shadcn/ui source components without breaking keyboard semantics, local changes or version-specific APIs.
Map the owners, entry points, contracts and verification paths relevant to a change, with source-backed relationships and explicit unknown coverage.
Qualify one derived code index against the intended checkout, source bytes, coverage and known query answers before using it for impact decisions.
Inspect authorized reference footage with timecoded visual and audio evidence, then turn its structure into a distinct adaptation brief rather than guessing from a transcript.
Assemble approved media into an explicit frame timeline and renderer handoff, validating asset identities and invalidating dependent timing after source revisions.
Review actual adjacent shots for visual, identity, product, caption and audio continuity while separating machine checks from subjective acceptance.
Compose a small task-relevant specialist preset from canonical skills, with explicit outputs and non-goals while leaving permissions and execution to the host.
Analyze predeclared engineering comparisons with complete task and attempt records, correct pairing and explicit uncertainty instead of equating fewer tokens with better results.
Inspect authorized local evaluation data for units, missingness, duplicate attempts, task coverage and grouping before calculating engineering comparisons.
Try another search or reset your filters.