AI Coding Agent Prompt Collection: 30 Examples
Explore 30 battle-tested AI coding agent prompts designed to streamline refactoring, debugging, test generation, and full-stack software development.
At a glance
- 30 prompts
- 8 min read
- copied 2 times
Jump to a prompt 30
- Category 1: Greenfield Feature Implementation
- Category 1: Greenfield Feature Implementation
- Category 1: Greenfield Feature Implementation
- Category 1: Greenfield Feature Implementation
- Category 1: Greenfield Feature Implementation
- Category 2: Refactoring & Code Modernization
- Category 2: Refactoring & Code Modernization
- Category 2: Refactoring & Code Modernization
- Category 2: Refactoring & Code Modernization
- Category 2: Refactoring & Code Modernization
- Category 3: Debugging & Root Cause Analysis
- Category 3: Debugging & Root Cause Analysis
- Category 3: Debugging & Root Cause Analysis
- Category 3: Debugging & Root Cause Analysis
- Category 3: Debugging & Root Cause Analysis
- Category 4: Automated Testing & Quality Assurance
- Category 4: Automated Testing & Quality Assurance
- Category 4: Automated Testing & Quality Assurance
- Category 4: Automated Testing & Quality Assurance
- Category 4: Automated Testing & Quality Assurance
- Category 5: Security Auditing & Performance Optimization
- Category 5: Security Auditing & Performance Optimization
- Category 5: Security Auditing & Performance Optimization
- Category 5: Security Auditing & Performance Optimization
- Category 5: Security Auditing & Performance Optimization
- Category 6: DevOps, Architecture & Documentation
- Category 6: DevOps, Architecture & Documentation
- Category 6: DevOps, Architecture & Documentation
- Category 6: DevOps, Architecture & Documentation
- Category 6: DevOps, Architecture & Documentation
AI prompts for coding agents are structured instructions that guide autonomous software development tools—such as Cursor, Claude Code, GitHub Copilot Workspace, and AutoGPT—to edit repositories, run terminal commands, write tests, and refactor codebases. Unlike basic chat prompts, effective agentic prompts provide clear repository context, file boundaries, operational constraints, and verification steps. Utilizing tailored prompts enables developers to automate end-to-end engineering tasks while maintaining code quality and reducing hallucinations.
Understanding AI Coding Agents and Why Prompting Matters
The landscape of software development has evolved from simple code completion to agentic workflows. Traditional AI coding assistants operate primarily on single-file inline suggestions. In contrast, modern AI coding agents possess file system access, terminal execution capabilities, and integration with protocols like the Model Context Protocol (MCP) to read multiple files, execute scripts, and inspect error logs independently.
Because autonomous agents can modify multiple files and run commands in your environment, imprecise prompts can lead to scope creep, unwanted dependency installations, or broken build pipelines. Providing highly structured ai prompts for coding agents serves as a guardrail, ensuring the model navigates the abstract syntax tree (AST), respects existing architectural patterns, and verifies its own work before presenting a pull request.
The Anatomy of a High-Impact Agent Prompt
To consistently produce production-ready code, prompts written for software agents should follow a predictable layout. Omitting context forces the model to make assumptions, which frequently results in technical debt.
- Role & Task Definition: Clearly state what the agent must build or fix.
- Scope & File Boundaries: Explicitly mention which directories or files the agent is allowed to edit or inspect.
- Context & Dependencies: Outline the target framework versions, existing design patterns, and internal libraries.
- Constraints & Rules: Detail performance thresholds, code style guidelines, security requirements, and forbidden packages.
- Verification Criteria: Command the agent to execute specific unit tests, linters, or build commands to validate its changes.
30 Production-Ready AI Prompts for Coding Agents
Below is a curated collection of 30 specialized prompts categorized by software engineering tasks. You can copy, modify, and pass these prompts directly to your AI agent or save them into project-level configuration files (such as .cursorrules or agent instruction files).
Category 1: Greenfield Feature Implementation
1. RESTful API Endpoint with Validation
Role: Senior Backend Engineer
Task: Create a new POST endpoint `/api/v1/subscriptions` in our Node.js/Express app.
Context: Refer to existing routes in `/src/routes/user.js` for structure and error handling middleware.
Constraints:
- Use Zod in `/src/schemas/subscription.js` for request body validation.
- Return standardized JSON responses using the wrapper in `/src/utils/response.js`.
- Do NOT edit `/src/app.js` directly; register the route in `/src/routes/index.js`.
Verification: Run `npm test tests/routes/subscription.test.js` and ensure all tests pass.2. Database Migration & ORM Schema Update
Task: Add a `soft_delete` column and `deleted_at` timestamp to the `users` table using Prisma.
Steps:
1. Update `prisma/schema.prisma` to include `deletedAt DateTime?` on the `User` model.
2. Run `npx prisma migrate dev --name add_soft_delete_to_users` using the system tool.
3. Update repository queries in `/src/repositories/userRepository.ts` to exclude soft-deleted records by default.
Verification: Run `npm run test:db` to confirm migration success and query behavior.3. Responsive Accessible UI Component
Task: Implement a reusable Modal component in Tailwind CSS and React (`src/components/common/Modal.tsx`).
Requirements:
- Follow accessibility (a11y) standards: focus locking, ESC key handling, and ARIA tags (`aria-modal="true"`).
- Support dynamic variants: `info`, `warning`, `danger`.
- Refer to `src/components/common/Button.tsx` for prop patterns and styling conventions.
Verification: Execute `npm run storybook` or check component rendering with `npm test Modal.test.tsx`.4. Third-Party Webhook Handler
Task: Implement a Stripe webhook handler endpoint at `/api/webhooks/stripe` in FastAPI (`app/api/webhooks.py`).
Context:
- Verify webhook signatures using the `stripe-python` library and secret from `settings.STRIPE_WEBHOOK_SECRET`.
- Handle `payment_intent.succeeded` and `customer.subscription.deleted` events.
Constraints: Return a `200 OK` rapidly; offload heavy processing to background tasks via Celery (`app/tasks/billing.py`).
Verification: Run `pytest tests/test_webhooks.py`.5. CLI Tool Subcommand
Task: Add a `backup` subcommand to our Go CLI app located in `cmd/backup.go`.
Requirements:
- Use the Cobra CLI framework established in `cmd/root.go`.
- Accept flags `--destination` (string, required) and `--compress` (bool, default false).
- Output progress bars using `github.com/schollz/progressbar/v3`.
Verification: Run `go test ./cmd/...` and test locally with `go run main.go backup --destination=/tmp`.Category 2: Refactoring & Code Modernization
6. Legacy Callback to Async/Await Conversion
Task: Refactor `/lib/fileProcessor.js` from Node.js error-first callbacks to modern `async/await` and `promises`.
Constraints:
- Do NOT change exported function signatures or external behavior.
- Replace manual `fs.readFile` callbacks with `fs.promises`.
- Wrap internal logic in proper `try/catch` blocks preserving custom error classes in `/lib/errors.js`.
Verification: Run `npm test test/fileProcessor.test.js`.7. Extract Subsystem into Micro-Service Module
Task: Isolate the notification logic in `/src/services/notifications.js` into an independent module under `/packages/notification-service`.
Steps:
1. Move email and SMS utilities into the new directory.
2. Define a clean interface using TypeScript in `/packages/notification-service/src/index.ts`.
3. Update remaining imports in the primary monorepo to source from the new package.
Verification: Run `pnpm build` across the monorepo to verify module resolution.8. JavaScript to Strict TypeScript Migration
Task: Convert `/src/utils/mathHelpers.js` to `/src/utils/mathHelpers.ts`.
Requirements:
- Provide strict types for all function inputs and return values. Avoid using `any`.
- Define explicit interfaces or types for complex object arguments.
- Enable `noImplicitAny` compatibility for this file.
Verification: Execute `npx tsc --noEmit` and confirm zero compiler errors.9. Applying Strategy Design Pattern
Task: Refactor `calculateDiscount()` in `/src/domain/discount.ts` which currently relies on a massive `switch` statement.
Goal: Apply the Strategy Pattern.
Steps:
1. Create a `DiscountStrategy` interface.
2. Implement explicit classes for `PercentageDiscount`, `FlatDiscount`, and `SeasonalDiscount`.
3. Use a strategy factory to select the appropriate instance.
Verification: Execute `jest src/domain/discount.test.ts`.10. Dependency Major Version Upgrade
Task: Upgrade Axios from v0.27.x to v1.x across `/src/api/client.ts`.
Context: Address breaking changes regarding request interceptors and error handling structures.
Steps:
1. Inspect `package.json` and bump `axios`.
2. Update options passing and custom instance creation syntax.
3. Fix standard error parsing where `error.response` property signatures have changed.
Verification: Run `npm run test:integration`.Category 3: Debugging & Root Cause Analysis
11. Memory Leak Diagnostics and Fix
Task: Investigate memory leak issue described in Issue #402 affecting `/src/websocket/server.ts`.
Steps:
1. Inspect how event listeners are registered on client disconnects.
2. Ensure all `EventEmitter.on()` handlers have matching `.off()` or `.removeListener()` calls inside cleanup functions.
3. Fix the leak without disrupting existing client connections.
Verification: Execute `npm run test:leak` and review heap usage logs.12. Concurrency Race Condition Remediation
Task: Fix race condition in stock deduction logic located in `app/services/inventory.py`.
Problem: Simultaneous checkout requests result in negative inventory levels.
Fix:
- Implement atomic updates or pessimistic locking using SQLAlchemy `with_for_update()`.
- Ensure transactions roll back completely on failure.
Verification: Run `pytest tests/test_inventory_concurrency.py`.13. Distributed Log & Stack Trace Resolution
Task: Diagnose cause of `NullPointerException` thrown in `OrderProcessorService.java:142`.
Context: Review error log: "java.lang.NullPointerException: Cannot invoke Address.getZipCode() because user.getAddress() is null".
Fix:
- Introduce defensive null-checking or Java `Optional` in `OrderProcessorService.java`.
- Provide fallback default handling for missing addresses during guest checkouts.
Verification: Run `./gradlew test --tests OrderProcessorServiceTest`.14. Edge Case Boundary Handling
Task: Resolve issue where `/src/utils/dateFormatter.js` fails on leap years and daylight saving transitions.
Context: Bug reported when parsing '2024-02-29' in UTC-5 timezones.
Instructions:
- Update parsing logic using `date-fns` to explicitly account for explicit timezone offsets.
- Add edge-case unit tests covering leap years and leap seconds.
Verification: Run `npm test test/dateFormatter.test.js`.15. Silent Error Suppression Cleanup
Task: Audit `/src/services/payment.ts` for empty `catch` blocks and unhandled promise rejections.
Steps:
1. Find all empty `catch (e) {}` blocks.
2. Replace them with proper logger output via `logger.error(e)`.
3. Re-throw custom domain exceptions where operation failure degrades system integrity.
Verification: Run `npm run lint` and `npm test`.Category 4: Automated Testing & Quality Assurance
16. TDD Feature Implementation (Test First)
Task: Follow TDD to implement a password strength validator in `src/utils/validator.py`.
Steps:
1. Write failing unit tests in `tests/test_validator.py` verifying requirements: min 12 chars, 1 uppercase, 1 number, 1 symbol.
2. Execute `pytest` to verify test failures.
3. Implement the minimum logic in `src/utils/validator.py` to make all tests pass.
4. Refactor logic for readability.
Verification: Ensure `pytest` passes with 100% coverage on `validator.py`.17. External Third-Party API Mocking
Task: Create robust mock tests for our OpenWeather API client in `tests/clients/weather_test.go`.
Requirements:
- Use `net/http/httptest` to mock remote server responses.
- Test scenarios: HTTP 200 (Valid JSON), HTTP 429 (Rate Limited), HTTP 500 (Server Error), and Network Timeout.
- Do NOT make real HTTP calls during test execution.
Verification: Run `go test -v ./tests/clients/...`.18. Playwright End-to-End User Flow
Task: Write a Playwright E2E test for the checkout workflow in `e2e/checkout.spec.ts`.
Flow:
1. Navigate to `/products/item-1`.
2. Click "Add to Cart".
3. Open Cart drawer, verify item exists, click "Checkout".
4. Fill payment form with dummy test card data.
5. Assert redirect to `/order-confirmation`.
Verification: Run `npx playwright test e2e/checkout.spec.ts`.19. Unit Test Suite for Uncovered Module
Task: Generate unit tests for `/src/helpers/urlParser.js` to achieve 90%+ code coverage.
Requirements:
- Test query param extraction, hash parsing, malformed URL handling, and empty strings.
- Use Jest assertion syntax.
Verification: Run `npm test -- --coverage src/helpers/urlParser.js`.20. Load Testing Script Generation
Task: Create a k6 performance test script in `/tests/performance/loadTest.js`.
Requirements:
- Target endpoint `GET /api/v1/products`.
- Ramp up from 1 to 50 virtual users (VUs) over 30 seconds, hold for 1 minute.
- Define threshold: 95% of requests must complete under 200ms (`http_req_duration: ['p(95)Category 5: Security Auditing & Performance Optimization
21. OWASP Top 10 Security Audit & Remediation
Task: Audit `/src/controllers/userController.js` for OWASP vulnerabilities.
Specific Focus:
- Identify and fix any indirect object references (IDOR) on profile edits.
- Ensure authentication checks run before database queries.
- Sanitize HTML outputs to prevent Stored XSS.
Verification: Run `npm run security:scan` and verify manual fixes via tests.22. SQL Injection Remediation
Fill in the blanks below, or click a highlighted word in the prompt.
Task: Fix potential SQL injection in `db/users.py`.
Problem: Raw string formatting used in query: `f"SELECT * FROM users WHERE email = '{email}'"`.
Fix: Replace raw string execution with parameterized queries using SQLAlchemy text constructs and parameter binding.
Verification: Execute `pytest tests/test_security_db.py`.23. Database Query & Index Optimization
Task: Optimize slow query performance reported on `GET /api/v1/orders`.
Steps:
1. Inspect `src/models/order.ts` and associated queries.
2. Fix N+1 query problem by implementing eager loading (include joins) for User and Product associations.
3. Generate a SQL migration file in `/migrations` adding an index on `orders(user_id, created_at)`.
Verification: Check query count log during `npm test tests/api/orders.test.ts`.24. Frontend Render & Bundle Optimization
Task: Optimize React performance in `src/pages/Dashboard.tsx`.
Requirements:
- Wrap expensive child calculations in `useMemo`.
- Implement dynamic imports (`React.lazy`) for heavy modal components (`AnalyticsChart`).
- Prevent unneeded re-renders using `React.memo` where appropriate.
Verification: Run `npm run build` and verify reduced main bundle chunk size.25. Environment Variable & Secret Hardening
Task: Audit project for hardcoded secrets or exposed keys.
Steps:
1. Search code base for potential hardcoded API tokens or secret strings.
2. Extract secrets into `.env.example` as dummy variables.
3. Access secrets safely via dynamic configuration wrappers in `/src/config/env.js`.
4. Ensure `.env` is verified inside `.gitignore`.
Verification: Execute `git diff` to ensure no active keys are present in version history.Category 6: DevOps, Architecture & Documentation
26. OpenAPI Specification Generation
Task: Generate an OpenAPI 3.0 YAML specification for routes in `/src/routes/auth.js`.
Output File: `docs/openapi/auth.yaml`.
Requirements:
- Document requests/responses for `/login`, `/register`, `/refresh-token`.
- Include HTTP status codes (200, 400, 401, 500), error payload schemas, and bearer auth headers.
Verification: Validate output using `npx @redocly/cli lint docs/openapi/auth.yaml`.27. Multi-Stage Dockerfile Construction
Task: Write an optimized, secure multi-stage `Dockerfile` for a Go application (`main.go`).
Requirements:
- Stage 1 (Builder): Use `golang:1.22-alpine`, compile static binary.
- Stage 2 (Runner): Use `gcr.io/distroless/static-debian12` or `alpine:latest`.
- Run application under non-root user (`appuser`).
- Keep final image size under 30MB.
Verification: Run `docker build -t app:test .` and inspect size via `docker images`.28. Production GitHub Actions Workflow
Task: Create a GitHub Actions workflow in `.github/workflows/ci.yml`.
Triggers: Push to `main` and all pull requests.
Steps:
1. Checkout code and setup Node.js v20 with pnpm caching.
2. Install dependencies with `pnpm install --frozen-lockfile`.
3. Run linter (`pnpm lint`), type-checker (`pnpm typecheck`), and tests (`pnpm test`).
Verification: Validate YAML syntax using `actionlint`.29. Architectural Decision Record (ADR) Creation
Task: Author an Architectural Decision Record in `docs/adr/0004-adopt-redis-caching.md`.
Context: We are introducing Redis for session storage and caching API responses.
Structure: Include Title, Status (Proposed), Context, Decision, and Consequences (Positive and Negative).
Verification: Verify document formatting matches `docs/adr/0001-template.md`.30. Repository Onboarding & Architecture Diagram
Task: Update `README.md` to reflect recent project restructurings.
Sections to generate/update:
1. Architecture Overview (include a Mermaid.js diagram illustrating client-to-database flow).
2. Local Development Setup (prerequisites, env setup, seed command execution).
3. Common Troubleshooting steps.
Verification: Render Markdown locally and check Mermaid diagram syntax validity.Comparing AI Coding Prompt Frameworks
Different development tasks call for different prompt techniques. The following table highlights common strategies when working with agentic developer tools:
| Prompt Strategy | Best Used For | Complexity | Primary Benefit |
|---|---|---|---|
| Zero-Shot Direct | Simple utilities, standalone functions, rapid boilerplate. | Low | Fast generation, low token usage. |
| Few-Shot / In-Context | Matching repository code style, custom framework patterns. | Medium | High consistency with existing codebases. |
| Chain-of-Thought (CoT) | Complex algorithm design, root-cause debugging, multi-file refactoring. | High | Reduces reasoning errors and logical hallucinations. |
| System-Constrained Agentic | Full feature build-outs, repository-wide edits, CI/CD setup. | Very High | Autonomous file discovery, built-in validation checks, end-to-end execution. |
Best Practices for Prompting Autonomous AI Agents
To maximize productivity when integrating AI prompts into your continuous development cycle, adhere to these technical best practices:
- Maintain Project Rules Files: Store baseline guidelines in rule files (such as
.cursorrules,CLAUDE.md, or.github/copilot-instructions.md). Define project tech stacks, code styles, and build scripts here so you don't need to repeat them in every prompt. - Enforce Automated Verification: Always specify a verification command (e.g., `npm test`, `go test`, `pytest`). Force the agent to execute tests and fix failures before returning control to you.
- Scope Scope & Boundaries: Restrict agent access to relevant subdirectories. Allowing an agent unconstrained write permissions across an entire repository can lead to unnecessary file churn.
- Provide Concrete Code Examples: When instructing an agent to adopt internal custom tools or wrappers, point explicitly to a file that exhibits correct usage (e.g., "Follow the error handling logic in
/src/controllers/base.ts"). - Commit Changes Frequently: Make a Git commit before running large agentic operations. This gives you a clear diff and makes rolling back erroneous agent edits straightforward.
Common Pitfalls to Avoid
When crafting prompts for AI agents, developers frequently fall into predictable traps that hinder model performance:
- Vague Instructions: Asking an agent to "make this file better" leads to arbitrary changes. Always define explicit metrics, such as memory usage, readability, or typing constraints.
- Over-Prompting in a Single Request: Expecting an agent to build a database migration, backend endpoint, frontend UI, and integration test suite simultaneously often causes timeouts or incomplete output. Break large goals into smaller, sequential prompts.
- Ignoring Local Logs and Test Output: Skipping automated validation forces you to manually inspect code for bugs that a basic test suite would have caught instantly.
- Assuming Up-to-Date Dependency Knowledge: Language models can hallucinate method signatures for recently released libraries. Provide precise version tags or reference documentation links when using newer packages.
Frequently Asked Questions
What is the difference between standard AI chat prompts and coding agent prompts?
Standard AI chat prompts generate isolated snippets or code explanations within a chat window. Coding agent prompts are designed for autonomous execution engines that read file systems, edit source code across multiple files, call terminal scripts, run tests, and perform iterative bug fixes directly in your development environment.
How do I stop an AI coding agent from hallucinating invalid library functions?
You can prevent hallucinations by scoping the prompt to explicit dependency versions, pointing the agent toward existing internal code examples, or enabling tools like the Model Context Protocol (MCP) to supply official documentation directly into the model's context window.
Can AI coding prompts be automated inside CI/CD pipelines?
Yes. By utilizing headless agent frameworks or CLI tools like Claude Code and GitHub Actions, you can automatically run agentic prompts on new pull requests to review security vulnerabilities, generate documentation, or fix failing unit tests automatically.
Which LLM is best for agentic software development?
Models optimized for tool usage, long-context comprehension, and precise code syntax perform best. Popular models for agentic tasks include Anthropic's Claude 3.5 Sonnet and OpenAI's o1/o3 series, integrated into agent environments like Cursor, Claude Code, and GitHub Copilot Workspace.
Conclusion
Writing precise ai prompts for coding agents transforms generative tools from simple code autocomplete utilities into reliable software development partners. By structuring prompts with clear contexts, precise boundaries, and automated verification loops, software teams can accelerate feature delivery and refactoring without sacrificing technical standards. Use the prompt templates above as a baseline, customize them to your stack, and embed verification scripts into every agent command to build a faster, more dependable AI-assisted workflow.