Developer resource library | DevPrompt Lab

Practical prompts, workflows, and repository rules for software engineers.

Published resources

• Analyze cache invalidation and freshness

  Map cache keys, stale-data risks, and invalidation triggers before optimizing reads.

• API error contract rule

  Keep error responses actionable, stable, and free of sensitive internals.

• Authorization and owner-scope rule

  Enforce access in server-side queries and tests for every private resource.

• Check release readiness and rollback

  Verify compatibility, backups, deployment order, and recovery evidence before release.

• Choose instruction files for coding tools

  Map project context into each tool's documented instruction format without inventing support.

• Collect useful project context for code generation

  Capture runtime, tooling, architecture, conventions, and quality requirements in one reviewable profile.

• Create a risk-based test plan

  Choose focused tests that protect behavior and important failure cases.

• Database owner-scope pattern

  Encode ownership checks and deletion behavior in queries and relational constraints.

• Debug with a reproducible hypothesis

  Turn an unclear symptom into a minimal reproduction and verified root cause.

• Design a clear REST API contract

  Specify routes, validation, authorization, errors, and pagination consistently.

• Design stable API pagination

  Specify bounded pages, deterministic ordering, and clear totals for collection endpoints.

• Deterministic test fixture rule

  Make test data explicit, isolated, and independent of production state.

• Investigate a slow request with evidence

  Locate latency in the full request path before suggesting an optimization.

• Localized SEO route rule

  Use explicit locale routes and translation relationships for canonical and hreflang output.

• Map repository module boundaries

  Explain ownership, entry points, dependency direction, and generated areas from the codebase.

• Map sensitive data through a feature

  Trace collection, storage, access, logging, sharing, and deletion of user data.

• PHP controller boundary rule

  Keep HTTP concerns thin and put reusable rules in testable domain code.

• Plan a controlled feature rollout

  Stage a feature release with explicit health signals and a fast disable path.

• Plan a feature in reviewable steps

  Turn a product request into scoped implementation tasks and acceptance checks.

• Plan a low-risk dependency upgrade

  Assess breaking changes, security impact, lockfiles, and verification before upgrading.

• Plan a repeatable, reversible data migration

  Preserve legacy rows and prove the migration can safely run again.

• Plan observability for a user journey

  Choose signals that explain failures and user impact without collecting excess data.

• Prepare a useful pull request review

  Explain change intent, risk, verification, and reviewer focus clearly.

• Privacy-safe logging rule

  Log enough to diagnose failures without recording credentials or private content.

• React component boundary rule

  Separate rendering, data access, and reusable domain behavior at clear boundaries.

• Refactor while preserving contracts

  Improve a module in small steps without changing its public behavior.

• Review a change for correctness and maintainability

  Focus a code review on behavior, edge cases, and future change cost.

• Review a generated instruction file

  Check format compliance, useful context, and absence of fabricated project facts.

• Review a React flow for accessibility

  Find keyboard, focus, semantics, and screen-reader barriers in a real interaction.

• Review a schema change before rollout

  Check constraints, compatibility, migration cost, and recovery for a data model change.

• Review a security-sensitive change

  Find exploitable defects and regressions in a focused code change.

• Review a SQL query for correctness and cost

  Check query semantics, indexes, locking, and safe parameterization.

• Review AI prompt-injection boundaries

  Trace untrusted content, model instructions, tool permissions, and consequential actions.

• Review session and API-key boundaries

  Verify that credential type, CSRF, role, and ownership checks match endpoint intent.

• Review translation completeness and meaning

  Check that localized content is complete, natural, and faithful to the source.

• Safe command execution rule

  Inspect targets and explain destructive effects before running commands that remove or overwrite data.

• Schema evolution compatibility rule

  Use expand, backfill, verify, switch, and contract stages for live data changes.

• Summarize an engineering change with evidence

  Explain what changed, why, how it was verified, and what remains uncertain.

• Triage an incident with a safe runbook

  Structure diagnosis, mitigation, communication, and recovery around evidence.

• Turn a user need into acceptance tests

  Write observable acceptance criteria for normal, empty, invalid, and denied paths.

• Validate untrusted data at a TypeScript boundary

  Build a runtime parser that narrows unknown input and returns useful errors.

• Write a blameless incident review

  Document impact, contributing conditions, response, and measurable follow-up work.

• Write a focused Cursor project rule

  Create a scoped .mdc rule with clear file patterns and actionable project conventions.

• Write an architecture decision record

  Capture context, alternatives, trade-offs, and consequences for one decision.

• Write documentation grounded in the code

  Create accurate developer documentation with verified steps and examples.

• Write durable Claude Code project memory

  Record stable project facts and useful commands without turning memory into a task log.

• Write effective Codex AGENTS.md instructions

  Use scoped AGENTS.md files to explain repository boundaries and verified workflows.

• Write useful Copilot repository instructions

  Keep `.github/copilot-instructions.md` concise, accurate, and specific to the codebase.