20+ Best AI Coding Prompts for Programming & Software Development (November 2026)

Production-Tested Prompts for Spec-Driven Coding, Debugging, MCP Servers, RAG Pipelines & Security Audits

20+ AI Prompts for Coding, Programming, and Software Development

Discover 20+ production-ready AI coding prompts to write clean code, isolate root-cause bugs, design spec-driven architectures, build Model Context Protocol (MCP) servers, and harden security across Python, TypeScript, Go, Rust, Java, React, and Node.js.

Quick Answer: What Makes an AI Coding Prompt Work in Production?

High-accuracy software engineering prompts use a Spec-First, Verify-Before-Done loop rather than open-ended generation. Always specify: 1) Exact Runtime & Versions (e.g., TypeScript 5.x, Node 22, Python 3.13), 2) Input/Output Contracts & Error States, 3) Non-Goals & Forbidden File Changes (preventing unrequested refactors), and 4) A Failing-to-Passing Test Verification Step before any pull request is marked complete.

Updated for Nov 2026 Coding Agents 20 Tested Engineering Templates Spec-Driven & MCP Ready Free to Copy & Use

Explore This Guide

Jump directly to any section of this article.

2026 AI Coding Assistant & Engineering Workflow Matrix

Match each software engineering task below to the right AI coding environment and verification rule:

Engineering Task Best AI Coding Tools (2026) Context File / Protocol Mandatory Verification Step
Multi-File Feature & Refactoring Claude Code, Cursor Agent, Windsurf CLAUDE.md / .cursorrules + EARS Spec Run typecheck + existing test suite after each file diff
Root-Cause Debugging & Race Conditions Claude Opus/Sonnet, OpenAI o-series, DeepSeek-R1 Stack trace + minimal reproduction test Write a failing regression test before applying the fix
MCP Servers & Agent Tooling Claude Code, Cursor, MCP Inspector JSON Schema / Zod strict input validation Separate read-only tools from write/destructive tools
Security Audit & PR Code Review Claude, GitHub Copilot Code Review, Snyk/Semgrep PR diff + originating ticket acceptance criteria Verify all package names exist (prevent slopsquatting)

20 AI Coding Prompts for Developers & Software Engineers

Select a category or browse all 20 software engineering prompts below

1. Review & Harden AI-Generated Code

DEBUG

Clean up code written by AI tools before it reaches production.

Review this AI-generated [language/framework] code as a skeptical senior engineer: 1) Find logic bugs, silent failure paths, missing error handling, and unhandled edge cases. 2) Flag duplicated logic, dead code, and unnecessary abstraction layers. 3) Verify that every imported package, method signature, and API actually exists in the specified version (flag any hallucinated methods). 4) Identify security vulnerabilities (injection, broken auth/authz, exposed secrets, unsafe input parsing). 5) List missing unit and integration test cases. 6) Provide the corrected, production-hardened code with brief inline comments explaining each fix without altering intended behavior.

Engineering Implementation Note

Paste your `package.json`, `requirements.txt`, or `go.mod` alongside the code snippet so the reviewer model can verify that every imported library and version-specific API call actually exists.

2. Spec-Driven Feature Specification (SDD)

ARCHITECT

Write the executable spec first so a coding agent builds the right thing.

Write a Spec-Driven Development (SDD) specification for [feature/system] before any code is written. Include: 1) Exact problem statement and user/system goal. 2) Explicit acceptance criteria in EARS-style notation ("WHEN [trigger], THE SYSTEM SHALL [deterministic response]"). 3) Data model schema, TypeScript/JSON interfaces, and API endpoint contracts. 4) Edge cases, rate limits, timeout behavior, and error states. 5) Out-of-scope items (non-goals) to prevent agent scope creep. 6) An executable Definition of Done (test commands that must pass) that an AI coding agent can verify itself against.

Engineering Implementation Note

Save the approved output as `specs/feature-name.md` in your repository and instruct Claude Code or Cursor to implement strictly against that file one acceptance criterion at a time.

3. Context Engineering File for AI Coding Agents

ARCHITECT

Persistent project-context file that keeps coding agents aligned across a large codebase.

Create a persistent repository context file (`CLAUDE.md`, `AGENTS.md`, or `.cursorrules`) for this [language/framework] project. Include: 1) High-level architecture and key directory/module boundaries. 2) Exact CLI commands to install, build, lint, typecheck, and run single unit tests. 3) Strict coding conventions, error-handling patterns, and naming rules. 4) Forbidden actions (files, migrations, or environment configs the agent must never modify without explicit human approval). 5) Common pitfalls agents have made in this stack and how to avoid them. Keep the file concise and token-efficient (<1,500 tokens) so it loads cleanly into every session.

Engineering Implementation Note

Whenever an AI coding agent makes a repeated mistake in a pull request, add a 1-line rule to the "Common Pitfalls" section of your `CLAUDE.md` file so the mistake never recurs.

4. Verify-Before-Done Debugging Loop

DEBUG

Agent reproduces, fixes, and proves its own fix before reporting done.

Debug this [language/framework] issue using a strict Verify-Before-Done loop: 1) Reproduce the bug first by writing a minimal, automated failing test case. 2) State your top root-cause hypothesis backed by stack-trace or state evidence before editing application code. 3) Apply the smallest surgical diff that fixes the root cause rather than masking the symptom. 4) Run the new regression test plus the existing test suite and linter to confirm zero collateral regressions. 5) If two fix attempts fail, stop immediately, revert your edits, and summarize what you ruled out instead of guessing a third time.

Engineering Implementation Note

Enforcing the "stop after two failed attempts" rule prevents autonomous coding agents from spiraling into destructive multi-file edits when a bug is caused by an external config issue.

5. Build a Model Context Protocol (MCP) Server

GENERATE

Create a Model Context Protocol server that lets AI assistants use your data or API safely.

Build a production-ready Model Context Protocol (MCP) server in [TypeScript (`@modelcontextprotocol/sdk`) / Python (`FastMCP`)] that exposes [data source or internal API] to AI assistants: 1) Define tools with clear names, descriptions, and strict Zod/Pydantic JSON input schemas. 2) Separate read-only query tools from state-changing write tools (marking destructive tools with explicit confirmation requirements). 3) Enforce least-privilege authentication, sanitize all error outputs so raw tokens or stack traces never leak into the LLM context, and add per-tool rate limiting. 4) Include a `README.md` with `claude_desktop_config.json` setup instructions and a test suite covering valid, boundary, and prompt-injected tool inputs.

Engineering Implementation Note

Test your generated server locally with `npx @modelcontextprotocol/inspector` to verify tool schemas, error responses, and stdio/SSE transport behavior before connecting it to an agent.

6. Production RAG Pipeline with Hybrid Search & Citations

GENERATE

Retrieval-augmented generation with semantic chunking, BM25 + vector hybrid search, reranking, and strict source citations.

Implement a production RAG pipeline in [TypeScript / Python] for [document type and use case]: 1) Document ingestion and structure-aware chunking (preserving markdown headers, code blocks, and tables) with configurable token overlap and metadata tags. 2) Hybrid retrieval combining dense vector embeddings (pgvector / Qdrant / Pinecone) with sparse BM25 keyword search, followed by a cross-encoder reranking step. 3) Grounded generation prompt that cites exact `[source_id, page]` markers for every claim and returns a deterministic "Insufficient evidence in knowledge base" response when retrieval confidence is below threshold. 4) Indirect prompt-injection sanitization and an evaluation script measuring Context Recall and Faithfulness.

Engineering Implementation Note

Always enforce user/tenant metadata filtering (`WHERE tenant_id = $1`) inside the vector and BM25 database query itself—never filter permissions in application memory after retrieval.

7. Evals & Regression Test Suite for LLM Features

TEST

Test non-deterministic AI features using structured assertions, golden datasets, and LLM-as-judge rubrics.

Create an automated evaluation (evals) and regression test suite for the LLM feature in this [language/framework] project: [describe feature]. Include: 1) A golden dataset of 30 realistic test cases covering happy paths, ambiguous queries, boundary inputs, and adversarial prompt-injection attempts. 2) Fast deterministic code graders (JSON schema validity, regex exclusions, latency, token count, and citation presence). 3) A calibrated LLM-as-judge grading prompt using a strict 0/1 binary rubric for factual faithfulness against reference context. 4) A CLI runner and CI gate that compares scores and token cost against the baseline main branch and fails the build if accuracy drops below threshold.

Engineering Implementation Note

Run fast deterministic assertions (schema validation, forbidden strings, max tokens) on every commit, and run the slower LLM-as-judge rubric suite on pull requests touching prompt templates.

8. Unit & Integration Tests with Edge Cases

TEST

Reliable automated tests that cover failures, boundary values, concurrency, and realistic fakes.

Write a comprehensive unit and integration test suite for this [language/framework] module: [paste code]. 1) Cover happy paths, error/exception paths, boundary values (0, -1, empty, null, max limits), malformed inputs, and concurrent/async race conditions. 2) Mock or fake only external network/IO boundaries while keeping internal domain logic 100% real (avoid brittle over-mocking that tests implementation details). 3) Add table-driven or property-based tests for pure transformation functions. 4) Use descriptive `given_when_then` test names and identify any untestable tight coupling in the source code that should be refactored via dependency injection.

Engineering Implementation Note

Use virtual time schedulers (e.g., `vi.useFakeTimers()` or `pytest` freeze-time) rather than real `sleep()` calls so timeout and retry tests execute in milliseconds.

9. Security Audit for AI-Era Applications

SECURITY

Find OWASP Top 10 vulnerabilities, indirect prompt injection, unsafe agent tools, and slopsquatted dependencies.

Perform a defensive application security audit on this [language/framework] codebase: [paste code]. 1) OWASP Web/API Risks: check for SQL/NoSQL/command injection, broken object-level authorization (BOLA/IDOR), XSS, CSRF, SSRF, insecure deserialization, and hardcoded secrets. 2) AI & LLM Specific Risks: check for indirect prompt injection from untrusted data, unvalidated tool/function-call execution, sensitive PII leakage into prompts/logs, and missing token/cost rate limits. 3) Supply-Chain Check: verify that all imported packages are real, canonical packages (flagging potential "slopsquatting" hallucinated package names). For each finding, output Severity, CWE ID, affected lines, a safe verification test, and the exact remediated code diff.

Engineering Implementation Note

Never pass raw LLM output directly into `eval()`, shell execution (`child_process.exec`), or unparameterized SQL—always constrain model outputs to a strict allow-listed enum or parameterized schema.

10. LLM API Cost, Latency & Token-Caching Optimizer

OPTIMIZE

Cut LLM API spend and time-to-first-token (TTFT) by 40%–70% using prompt caching, model routing, and batch APIs.

Audit this application's LLM API integration code and optimize for both cost and latency: 1) Prompt Caching Layout: restructure prompt construction so static system instructions, tool definitions, and few-shot examples sit at the exact prefix to maximize automatic/explicit prompt-cache hit rates. 2) Tiered Model Routing: identify calls currently using expensive frontier models that can be routed to fast flash/haiku/mini models or small open-weight models without quality loss. 3) Output & Batch Efficiency: enforce concise structured JSON schemas, move non-interactive background jobs to 50%-discounted Batch APIs, and add circuit-breaker token budgets per user. Provide refactored code and estimated monthly savings at 10k, 100k, and 1M requests.

Engineering Implementation Note

Placing dynamic user timestamps or per-request variables at the very top of a system prompt invalidates prefix prompt caching—always append dynamic context at the end of the prompt.

11. Web Performance & Core Web Vitals Optimization

OPTIMIZE

Make pages faster for users and for search rankings by fixing LCP, INP, and CLS bottlenecks.

Optimize this [framework] web page or application for Core Web Vitals (LCP < 2.5s, INP < 200ms, CLS < 0.1): 1) Diagnose the exact bottlenecks hurting Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS). 2) Provide prioritized before-and-after code diffs covering: hero image `fetchpriority="high"` and responsive `srcset`, WOFF2 font preloading and `size-adjust` fallbacks, deferring render-blocking third-party scripts, breaking up long main-thread JS tasks (>50ms), and reserving explicit aspect-ratio boxes for dynamic media/ads. 3) Include verification steps using Chrome DevTools Performance panel and Lighthouse CLI.

Engineering Implementation Note

Never apply `loading="lazy"` to your primary above-the-fold hero image—use `loading="eager" fetchpriority="high"` on the LCP element and lazy-load only below-the-fold images.

12. Codebase Onboarding & Safe Refactor Plan

EXPLAIN

Understand an unfamiliar project quickly and plan incremental changes without breaking production.

Analyze this [language/framework] codebase and generate a developer onboarding and safe refactoring guide: 1) Summarize the core domain architecture and module boundaries. 2) Trace the end-to-end lifecycle of a primary request or data mutation in plain ASCII/text diagram format. 3) List the top 5 entry-point files a new engineer should read first and why. 4) Identify high-coupling hotspots, circular dependencies, or fragile global state. 5) Propose a Strangler-Fig incremental refactor plan where every step is small, behind a feature flag or interface seam, and protected by characterization tests before any logic is moved.

Engineering Implementation Note

Write "characterization tests" (tests that lock in the current actual output of legacy code, warts and all) before starting Step 1 of any refactoring plan.

13. CI/CD Pipeline with AI Review Gates

DEVOPS

Automated build, test, security scan, preview environment, and deployment with safe rollbacks.

Create a production-grade CI/CD pipeline for [app stack] using [GitHub Actions / GitLab CI]: 1) Fast parallel stages with deterministic lockfile dependency caching, linter, strict typecheck, and unit/integration test matrix. 2) Automated SAST security scanning, secret detection, and dependency vulnerability audit. 3) Ephemeral preview deployment for every pull request plus an automated AI PR review comment step (read-only permissions, never auto-merging). 4) Staged production deployment using OIDC short-lived cloud credentials (zero long-lived static cloud keys), post-deploy smoke-test health checks, and automatic rollback if error rates spike.

Engineering Implementation Note

Pin third-party GitHub Actions to full 40-character commit SHAs rather than mutable tags (`@v4`) to protect your CI runner against supply-chain tag hijacking.

14. Parallel Multi-Agent Coding Plan (Git Worktrees)

ARCHITECT

Orchestrate multiple coding agents working in parallel across isolated `git worktree` branches without merge collisions.

Design a parallel multi-agent software development plan for building [feature/project] using isolated `git worktree` branches: 1) Shared Contract First: define the shared TypeScript/Protobuf/OpenAPI interfaces and database schema that must be committed to the base branch before parallel work begins. 2) Disjoint Task Decomposition: split the implementation into 3 to 4 independent workstreams (e.g., Backend API, Frontend UI, Worker/Queue, E2E Tests) with strictly non-overlapping file ownership so agents never edit the same file simultaneously. 3) Per-Worktree Agent Briefs: provide the exact prompt, allowed file paths, and verification test command for each agent. 4) Integration & Merge Order: specify the exact merge sequence and contract integration test.

Engineering Implementation Note

Use `git worktree add ../feature-ui feat/ui` and `git worktree add ../feature-api feat/api` so two Claude Code terminal sessions can run builds and tests concurrently without overwriting each other's working tree.

15. AI Agent Tool-Use Security Guardrails

SECURITY

Define what an autonomous coding or ops agent is and isn't allowed to touch before giving it real tool access.

Design a defense-in-depth security policy and middleware wrapper for an autonomous AI agent with tool access (filesystem, shell, database, external APIs) in [environment]: 1) Tiered Autonomy Matrix: Tier 1 Auto-Allowed (read-only queries, local unit test runs), Tier 2 Human-in-the-Loop Confirmation Required (database writes, external emails/webhooks, package installs), and Tier 3 Hard-Blocked (production table drops, secret file reads, force-pushes). 2) Sandboxing & Network Egress: container/microVM isolation rules, path-traversal prevention, and domain allow-listing. 3) Immutable Audit Trail & Circuit Breaker: structured JSON logging of every tool call and an automatic kill-switch on repeated errors or token-spend spikes.

Engineering Implementation Note

Enforce tool allow-lists and path restrictions in deterministic host code (middleware/sandbox permissions), never solely through natural-language "do not touch X" instructions in the system prompt.

16. Agentic CI/CD Pipeline with Automated Spec-to-PR Verification

DEVOPS

A CI/CD pipeline where an AI reviewer verifies every pull request diff against its originating spec and test coverage before human review.

Design an agentic pull-request verification workflow for [project/CI platform]: 1) Spec-to-Diff Alignment Check: parse the linked issue/spec acceptance criteria and verify that every requirement is implemented in the PR diff and covered by an assertion in the test diff. 2) Anti-Slop & Scope-Creep Detector: flag unrequested formatting changes, orphaned helper functions, silent deletions of existing assertions, or new dependencies not justified by the spec. 3) Security Boundary Rule: run the AI reviewer in an isolated job with read-only repository tokens (never exposing production deployment secrets to PR workflows triggered from forks). 4) Output a concise, structured PR review comment table with blocking vs. non-blocking findings.

Engineering Implementation Note

In GitHub Actions, never use `pull_request_target` with untrusted code checkouts when running AI review scripts, as malicious PR text or code could exfiltrate repository secrets.

17. Staff-Engineer Code Review for Agent-Generated PRs

REVIEW

Catch the subtle failure modes AI coding agents introduce—such as swallowed errors, tautological tests, and N+1 queries.

Review this [language/framework] pull request diff as a Staff Engineer specifically auditing for AI-agent failure modes: 1) Tautological or Mock-Heavy Tests: flag tests that only assert a mock was called without testing real state/output behavior. 2) Swallowed Exceptions & Silent Fallbacks: flag generic `catch (e) { return null; }` blocks that hide real production failures. 3) Performance & Database Traps: check for N+1 queries inside loops, unbounded memory arrays, missing pagination, or blocking synchronous I/O. 4) Spec Divergence & Over-Abstraction: identify places where the agent invented unnecessary wrapper classes or diverged from the existing codebase's patterns. Provide actionable diff suggestions ranked by Critical, Major, and Minor.

Engineering Implementation Note

AI coding agents frequently pass tests by weakening the test assertion or adding a hardcoded fallback—always review the `test/` diff before reading the implementation diff.

18. Executable Spec to Clean Architecture Refactor

ARCHITECT

Refactor coupled legacy code into Clean/Hexagonal Architecture while using contract tests to prove external behavior never changed.

Refactor this [language/framework] module into Clean / Hexagonal Architecture (Ports & Adapters) anchored to a behavior-preservation contract: 1) Behavior Lock: write a contract test suite capturing the exact current inputs, outputs, side effects, and error codes of the legacy module. 2) Layer Separation: extract pure Domain Entities and Use Cases with zero framework or database imports, defining inbound and outbound Port interfaces. 3) Adapters: move HTTP controllers, ORM/SQL queries, and third-party SDK calls into outer Adapter implementations injected via constructor DI. 4) Verify that the original contract test suite passes 100% unmodified against the refactored architecture.

Engineering Implementation Note

Enforce inward-pointing dependencies with a linter rule (such as `eslint-plugin-boundaries` or `import-linter`) so future PRs cannot import database ORM models directly into domain use cases.

19. Cross-Language Migration with Differential Test Verification

GENERATE

Port modules across languages (e.g., Python/PHP/Java to TypeScript/Go/Rust) with a differential test harness proving parity.

Migrate this [source language] module to idiomatic [target language]: 1) Idiomatic Translation: use native [target language] concurrency, error-handling, and type-system patterns rather than a naive line-by-line transliteration. 2) Semantic Pitfall Audit: explicitly document and handle language differences in integer overflow, floating-point rounding, timezone/date parsing, null/undefined semantics, and UTF-8 string indexing. 3) Differential Test Harness: generate a shared JSON fixture file of 25 inputs (including edge cases) and a test runner that executes both the old [source language] module and new [target language] module to assert 100% byte-for-byte output parity.

Engineering Implementation Note

Pay special attention to regex flavor differences, integer division truncation (e.g., Python `//` vs. Go/C `/` on negative numbers), and JSON key ordering when verifying cross-language parity.

20. MCP-Integrated Multi-Tenant SaaS Backend Template

GENERATE

Scaffold a multi-tenant SaaS backend that exposes both REST/GraphQL APIs for web clients and scoped MCP tools for AI agents.

Generate a multi-tenant SaaS backend in [TypeScript (Next.js/Fastify) / Python (FastAPI) / Go] with native Model Context Protocol (MCP) support: 1) Core Domain & Auth: shared service layer enforcing tenant isolation (`tenant_id`), RBAC permissions, and idempotency keys. 2) Dual Transport Exposure: expose core domain actions simultaneously as standard REST API endpoints (with OpenAPI 3.1 docs) and as an authenticated MCP Server (SSE/Streamable HTTP transport) for AI agent clients. 3) Scoped Agent Tokens: issue tenant-scoped OAuth/API tokens that restrict connected AI agents to specific read/write scopes and per-minute rate limits. 4) Include database schema, structured audit logging, and integration tests.

Engineering Implementation Note

Make your REST controllers and your MCP tool handlers thin wrappers around the exact same Domain Use-Case service so authorization and validation logic is never duplicated.

Optimizing Your Software Development Workflow with AI

AI coding tools are most useful when they support a clear development process rather than replace it. Before asking an assistant to write code, define the feature, explain the existing project structure, and identify the constraints that matter: language, framework, runtime version, API contracts, database rules, and coding conventions. Share only the relevant files and context, and remove credentials, tokens, customer data, and other secrets before sending code to an external service.

Break larger tasks into small, reviewable steps. Ask the assistant to outline the approach first, implement one module, write tests, and then review the changes against the requirements. Keep changes in version control, run the project's existing checks, and review the diff before accepting them.

Step-by-Step Guide: Generating Production-Ready Code from Prompts

Start by describing the feature in terms that can be tested. Specify the programming language and version, framework, existing interfaces, expected inputs and outputs, validation rules, error states, performance requirements, and any edge cases. If the code must fit into an existing application, include the relevant files or signatures and explain what must not change.

Next, ask your AI coding assistant to propose a short implementation plan before generating the code. Have it identify files to create or update, dependencies it intends to use, and any assumptions that need confirmation. Before merging, run formatting, linting, type checks, and unit and integration tests in your real project environment. Pair these backend and architecture templates with our 40+ Mobile App Development Prompts and 40+ Website Design & Full-Stack Prompts.

The Science Behind Effective AI Coding and Architecture Prompts

Effective coding prompts reduce ambiguity by specifying the problem, the repository context, non-negotiable constraints, and observable acceptance criteria. For architecture work, also state expected scale, availability needs, data sensitivity, deployment environment, and operational limits so the model compares realistic trade-offs instead of suggesting over-engineered boilerplate.

Best Practices for Refactoring and Securing AI-Generated Code

Refactoring should make code easier to understand or change without altering external behavior. Lock existing behavior with contract or characterization tests first, request small incremental diffs, and run automated security and dependency checks alongside human code review. For autonomous agent workflows, explore our dedicated 20+ AI Agent Prompts.

Adnan Khan - Founder of I Love AI Prompt

About the Author

Adnan Khan

Founder of I Love AI Prompt • Software Engineer & AI Prompt Researcher

Hi, I'm Adnan Khan, a software engineer and the founder of I Love AI Prompt. I research, test, and publish AI prompts for software developers, architects, creators, and businesses. Every prompt on this website is reviewed and refined to improve code quality, security, and maintainability across today's leading AI coding tools.

This 20-prompt software engineering guide was built from hands-on testing across Claude Code, Cursor, GitHub Copilot, and ChatGPT to help developers ship reliable, well-tested software.

Frequently Asked Questions

What was updated on this page in November 2026?

This guide was updated in November 2026 with 20 spec-driven coding and agentic engineering prompts, a new 2026 AI Coding Assistant Matrix, unique implementation notes for every prompt card, and working category filters across all 8 engineering disciplines.

What are AI coding prompts?

AI coding prompts are structured engineering instructions that guide AI coding assistants to generate clean code, write specifications, debug root causes, build unit tests, and audit security across programming languages.

Can AI coding prompts be used for production software development?

Yes. Professional engineers use spec-driven prompts (Prompts #1–#4) to define acceptance criteria, generate vertical slices, run automated regression tests, and review pull request diffs before merging to production.

Are AI coding prompts beginner-friendly?

Yes. Beginners can use Prompts #12 and #17 to understand unfamiliar codebases, trace data flows step-by-step, and learn best practices while building applications.

Which AI tools work best for these coding prompts in 2026?

These prompts are optimized for agentic IDEs and reasoning models—including Claude Code, Cursor, Windsurf, GitHub Copilot, ChatGPT (o-series / GPT-4o), Google Gemini Pro, and DeepSeek-R1.

How do I stop AI coding tools from breaking existing features when fixing a bug?

Use the Verify-Before-Done Debugging Loop (Prompt #4) and Context File (Prompt #3): require the agent to write a minimal failing test first, apply the smallest surgical fix, and run your full existing test suite before marking the task complete.