DevHubTools Robot Mascot
DevHubTools
Marketplace/Toolkits/150+ AI Prompt Engineering Pack for Copilot, Claude & ChatGPT
Toolkits1.0 • Released 2026-11-03

150+ AI Prompt Engineering Pack for Copilot, Claude & ChatGPT

Stop getting generic AI code and start using structured system prompts engineered for senior developers, covering automated PR reviews, SQL query optimization, legacy code to TypeScript migration, Salesforce Apex bulkification, and 1-click tutorial-to-carousel content repurposing.

By Avnish Yadav · Updated

Cover of the 150+ AI Prompt Engineering Pack for Copilot, Claude & ChatGPT, showing a developer prompt toolkit.

Architecture Overview & Problem Solved

This pack gives developers a set of structured system prompts built for senior-level work rather than generic AI output. It spans automated PR reviews, SQL query optimization, legacy code to TypeScript migration, Salesforce Apex bulkification, and 1-click tutorial-to-carousel content repurposing, so you can apply consistent, engineered prompting across your everyday development and content workflows.

Why builders use this kit: Generic AI output wastes senior developers' time: assistants produce loosely typed code, unparameterized queries and boilerplate that still needs heavy rework. This pack provides structured system prompts and instruction templates aimed at automated PR reviews, SQL tuning, legacy-to-TypeScript migration, Apex bulkification and content repurposing so results start closer to production quality.
Free
Free download
MIT / Commercial
Get it free

Enter your email and we'll send you the download for 150+ AI Prompt Engineering Pack for Copilot, Claude & ChatGPT.

We'll ask you to confirm your email first. Confirming also subscribes you to the DevHubTools newsletter; unsubscribe any time.

Tested Compatibility Versions

External API Costs

Secrets & Credentials Handling

Known Limitations

Results depend on the model, tooling and context you supply, so prompts may need adjustment for your stack and conventions. The pack is a prompt and template library, not a code-generation service, and it does not guarantee specific performance or quality outcomes. It is listed as coming soon, so availability and final contents may change.

What's Included in the Package

  • 50 Architecture, Refactoring & Security Audit prompts for Claude & GPT-4o
  • 40 Inline `.github/copilot-instructions.md` & Cursor rules templates
  • 30 DevOps, Dockerfile, Kubernetes & SQL performance tuning prompts
  • 30 Content Creator & Developer Marketing prompts (Code -> Blog -> YouTube -> Reels)

Installation & Setup Instructions

    Example Input Payload
    Example Verified Output
    Included Code / Node Preview
    # .github/copilot-instructions.md (Included in Prompt Pack)
    You are a Principal Full-Stack Architect. For every code generation:
    1. Enforce strict TypeScript types (zero 'any').
    2. Prefer early returns and explicit error boundaries.
    3. Parameterize all SQL/Drizzle queries and validate inputs at API boundaries.
    4. Include concise JSDoc comments explaining WHY, not WHAT.

    Deep Technical Specifications & Architectural Guide

    How it works

    This ai prompt engineering pack is a set of structured system prompts and instruction templates you drop into the tools you already use. Each prompt sets a role, constraints, and an output contract up front, so the model starts from your conventions instead of guessing. You paste a prompt into Claude or ChatGPT, or commit an instruction file to your repo for Copilot and Cursor, then supply the code, schema, or diff you want worked on.

    The four components

    • 50 architecture, refactoring and security audit prompts for Claude and GPT-4o. These set the model up as a reviewer or architect with explicit rules: strict typing, early returns, parameterized queries, input validation at boundaries.
    • 40 inline .github/copilot-instructions.md and Cursor rules templates. Repo-level instructions that apply to every generation in that project, not just one chat.
    • 30 DevOps, Dockerfile, Kubernetes and SQL performance tuning prompts. Aimed at query plans, index choices, container hygiene, and manifest review.
    • 30 content creator and developer marketing prompts. Turn a tutorial into a blog post, then a video script, then short-form copy.

    A typical loop

    1. Pick the prompt that matches the task — a PR review, a slow query, a legacy module to port.
    2. Fill in the placeholders: language, framework, schema, constraints, what "done" looks like.
    3. Run it against your code or diff.
    4. Read the output as a draft from a strong reviewer, not as final code. Apply, test, adjust.

    Here's the shape of an instruction template, from the pack:

    # .github/copilot-instructions.md (Included in Prompt Pack)
    You are a Principal Full-Stack Architect. For every code generation:
    1. Enforce strict TypeScript types (zero 'any').
    2. Prefer early returns and explicit error boundaries.
    3. Parameterize all SQL/Drizzle queries and validate inputs at API boundaries.
    4. Include concise JSDoc comments explaining WHY, not WHAT.
    

    What to expect

    Results depend on the model, the tooling, and the context you supply. Prompts may need adjustment for your stack and conventions — treat the templates as a starting point, not a fixed contract. The pack is a prompt and template library, not a code-generation service, and it doesn't guarantee specific performance or quality outcomes. It's listed as coming soon, so availability and final contents may change.

    Requirements

    This is a prompt and template library, so there's no runtime, no dependency tree, and nothing to install. What you need is the tooling you already use and enough context to feed the prompts properly.

    AI tools

    The prompts and templates are written for Copilot, Claude, and ChatGPT, including GPT-4o. The instruction templates target repository-level setups such as .github/copilot-instructions.md and Cursor rules, so you'll want a repo where you can commit those files and a Copilot or Cursor setup that reads them.

    Editor and repository access

    For the inline instruction templates, you need write access to the repository root so the agent picks up the rules file. If your team gates changes through pull requests, plan for the rules file to go through review like any other config change — it affects everyone's generated output.

    Context you supply

    Every prompt in the pack depends on what you give it. In practice that means:

    • The actual code, diff, or query you want reviewed or tuned
    • Your stack and conventions — framework, language version, lint rules, naming patterns
    • Schema or type definitions where the prompt touches data access
    • Error output, explain plans, or logs for debugging and tuning prompts

    Thin context produces thin output. The prompts are structured to ask for specifics, but they can't infer your conventions from nothing.

    Model access and limits

    You need API or chat access to whichever model you're targeting, and enough context window to hold the code you're passing in. Large files may need to be split before they fit. Check your plan's rate limits if you're running batch reviews across many pull requests.

    What it won't do

    Results depend on the model, the tooling, and the context you supply, so expect to adjust prompts for your stack and conventions. The pack is a prompt and template library, not a code-generation service, and it doesn't guarantee specific performance or quality outcomes. It's listed as coming soon, so availability and final contents may change — check the current listing before you plan around it.

    Customizing it

    The prompts are starting points, not fixtures. Every template in the pack is plain text you can edit, and the ones that matter most are the instruction files that live in your repo.

    Start with the instruction templates

    The 40 inline .github/copilot-instructions.md and Cursor rules templates are the highest-leverage place to customize, because they apply to every generation in that repository rather than a single chat. Take the closest template and rewrite the rules to match what your codebase actually enforces:

    # .github/copilot-instructions.md
    You are a Principal Full-Stack Architect. For every code generation:
    1. Enforce strict TypeScript types (zero 'any').
    2. Prefer early returns and explicit error boundaries.
    3. Parameterize all SQL/Drizzle queries and validate inputs at API boundaries.
    4. Include concise JSDoc comments explaining WHY, not WHAT.
    

    Swap the stack-specific lines for yours. If you're on Apex, the TypeScript and Drizzle rules don't apply — replace them with your bulkification and governor-limit conventions. If you're on Prisma instead of Drizzle, say so explicitly; models default to the most common pattern unless told otherwise.

    Make the rules specific to your conventions

    Generic instructions produce generic output. The customization that pays off is naming your actual constraints:

    • Naming and structure — file layout, module boundaries, where shared types live.
    • Error handling — your result type, your logging call, how you surface failures to callers.
    • Testing — the framework, where tests sit, what a minimal test looks like in your repo.
    • Things to never do — deprecated internal APIs, direct DB access from controllers, any, whatever your team keeps catching in review.

    Keep the file short. A tight list of ten rules the model can actually follow beats a page of prose it will skim.

    Tune the audit and tuning prompts per project

    The architecture, refactoring, and security audit prompts take context you supply. Add your threat model, your compliance constraints, and the parts of the codebase that are off-limits to change. Same for the SQL and Kubernetes tuning prompts: include your engine version, your orchestration setup, and your actual performance targets so the suggestions land in the right range.

    Iterate like code

    Treat a prompt change like any other change: keep it in version control, note what you changed and why, and revert when output gets worse. Expect a few rounds of adjustment per stack — the pack is a template library, and results depend on the model, tooling, and context you provide.

    What's inside: 150 prompts

    The pack's PDF: cover and a sample page
    • Architecture, refactoring & security audits · 50
      • Review a pull request diff by severity
      • Find the security holes in one file
      • Threat-model a new feature
      • Spot business logic in UI components
      • Plan a refactor of a large file into modules
      • Find duplicated logic across files
      • Review error handling end to end
      • Check a function for edge cases
      • Design the interfaces for a use case
      • Review a database schema
      • Audit authentication and session handling
      • Check authorisation on every endpoint
      • Find secrets and risky config
      • Review input validation at the boundary
      • Review webhook handling
      • Make a function testable
      • Explain legacy code before changing it
      • Write characterisation tests for legacy code
      • Review concurrency and race conditions
      • Review an API design
      • Check dependency risk in a manifest
      • Plan a strangler migration off a legacy module
      • Review logging and observability
      • Review a migration for production safety
      • Find performance problems in a code path
      • Review a caching strategy
      • Write a technical design review
      • Harden file upload handling
      • Review rate limiting and abuse protection
      • Turn a bug report into a root cause
      • Review feature flag usage
      • Map the blast radius of a change
      • Review a pull request for test quality
      • Simplify over-engineered code
      • Check data privacy handling
      • Review a background job design
      • Review a pagination implementation
      • Audit a Dockerfile for security
      • Review a GitHub Actions workflow for security
      • Review code for accessibility issues
      • Decide between two architecture options
      • Review multi-tenant data isolation
      • Review secrets management
      • Review an event-driven flow
      • Review a retry and timeout policy
      • Check a codebase against its own conventions
      • Review error messages shown to users
      • Prepare a security review checklist for a release
      • Review state management in a frontend app
      • Review an infrastructure-as-code change
    • Copilot instructions & Cursor rules · 40
      • Next.js App Router project rules
      • React + Vite SPA rules
      • Node.js + Express API rules
      • NestJS service rules
      • Python FastAPI rules
      • Django project rules
      • Go service rules
      • Rust project rules
      • Java Spring Boot rules
      • .NET Web API rules
      • Salesforce Apex rules
      • Lightning Web Components rules
      • TypeScript library rules
      • Monorepo rules
      • Testing rules for any project
      • Security rules for generated code
      • Accessibility rules for UI code
      • Tailwind CSS rules
      • Drizzle ORM rules
      • Prisma rules
      • SQL migration rules
      • GraphQL API rules
      • React Native rules
      • Flutter rules
      • Terraform rules
      • Docker and Kubernetes rules
      • GitHub Actions rules
      • Data pipeline rules (Python)
      • Pull request review rules for Copilot
      • Commit message and PR description rules
      • Documentation writing rules
      • Error handling rules
      • Logging and observability rules
      • REST API design rules
      • Clean architecture rules
      • Laravel / PHP rules
      • Ruby on Rails rules
      • Vue / Nuxt rules
      • SvelteKit rules
      • Angular rules
    • DevOps, Docker, Kubernetes & SQL tuning · 30
      • Read a SQL EXPLAIN plan
      • Design indexes for a set of queries
      • Rewrite a slow SQL query
      • Fix an N+1 query problem
      • Find the slowest queries in production
      • Tune database connection pooling
      • Plan a large table backfill
      • Find and fix lock contention
      • Choose between a read replica and a cache
      • Write a production-ready Dockerfile
      • Shrink a Docker image
      • Write docker-compose for local development
      • Write Kubernetes manifests for a web service
      • Debug a CrashLoopBackOff pod
      • Set Kubernetes resource requests and limits
      • Write a zero-downtime deployment plan
      • Write a CI pipeline
      • Speed up a slow CI pipeline
      • Write a runbook for an alert
      • Write a post-incident review
      • Set up useful alerts
      • Harden a Linux server
      • Write an nginx config for an app
      • Plan backups and a restore test
      • Estimate and cut cloud costs
      • Write a Makefile or task runner for a project
      • Review environment configuration
      • Write a database maintenance plan
      • Load-test an endpoint
      • Plan a database major version upgrade
    • Content & developer marketing · 30
      • Turn a blog post into a tutorial outline
      • Write a technical blog post from notes
      • Write a LinkedIn post from a tutorial
      • Turn a tutorial into an X/Twitter thread
      • Create a carousel from a tutorial
      • Write a YouTube video script from a post
      • Write short video scripts (Shorts/Reels)
      • Write a developer newsletter issue
      • Write a product launch announcement
      • Write a README that converts
      • Write documentation from code
      • Write a changelog entry for users
      • Write a comparison post fairly
      • Generate blog post ideas from your work
      • Write SEO metadata for a post
      • Edit a draft for clarity
      • Create a case study from a project
      • Repurpose one post into a week of content
      • Write an email course from a guide
      • Write a landing page for a developer product
      • Write a conference talk proposal
      • Write a developer-friendly API announcement email
      • Write a project case for a portfolio
      • Write a GitHub release note
      • Write a tutorial introduction that keeps readers
      • Write alt text and captions for technical images
      • Answer a developer question as a post
      • Create a content calendar for a month
      • Turn a code snippet into a teaching post
      • Review content for technical accuracy

    Free preview

    Review a pull request diff by severity · Architecture, refactoring & security audits

    Use case

    Get a focused review of a diff with each issue ranked, instead of a wall of style comments.

    Prompt

    You are a principal engineer reviewing a pull request in a {language} codebase.
    Review ONLY the diff below. Ignore formatting and naming unless it hides a bug.
    
    {diff}
    
    For each real issue, output one line:
    <file>:<line> | <blocker|major|minor> | <what is wrong> | <concrete fix>
    
    Then a final line: "Verdict: approve" or "Verdict: request changes" with one sentence why.
    If you find nothing above minor, say so plainly.

    Example input

    diff --git a/src/api/users.ts b/src/api/users.ts + const rows = await db.query(`select * from users where email = '${email}'`);

    Example output (illustrative)

    src/api/users.ts:14 | blocker | SQL built from user input (injection) | use a parameterised query: db.query('select * from users where email = $1', [email]) Verdict: request changes. The injection must be fixed before merge.

    Illustrative example (AI-generated); results vary with the model and your context.

    Tips

    Paste the diff, not whole files: the model focuses on what changed. Add the PR description so it can check intent against the code.

    Find the security holes in one file · Architecture, refactoring & security audits

    Use case

    A targeted security pass over a single file: injection, auth gaps, secrets, unsafe input handling.

    Prompt

    Act as an application security reviewer. Audit this {language} file from a {framework} app.
    
    {code}
    
    Check for: injection (SQL, shell, template), missing authentication or authorisation checks, secrets in code,
    unsafe deserialisation, path traversal, SSRF, weak randomness for tokens, and user input reaching sensitive sinks unvalidated.
    
    Output a table: Line | Issue | Severity (critical/high/medium/low) | Exploit in one sentence | Fix.
    Only list issues you can point to in the code. Do not list generic advice.

    Example input

    export async function GET(req) { const file = new URL(req.url).searchParams.get('f'); return new Response(await readFile('./uploads/' + file)); }

    Example output (illustrative)

    Line 3 | Path traversal | high | ?f=../../.env reads any file the server can read | resolve the path and check it stays inside ./uploads, or look files up by id

    Illustrative example (AI-generated); results vary with the model and your context.

    Tips

    Tell it the framework: some protections (CSRF, escaping) come built in and should not be flagged. Run it per file; whole-repo pastes get shallow answers.

    Spot business logic in UI components · Architecture, refactoring & security audits

    Use case

    Find logic that belongs in the domain or service layer but lives in components or route handlers.

    Prompt

    You are reviewing a {framework} codebase for layering problems.
    
    {code}
    
    Find every place where business rules (pricing, permissions, validation, state transitions) live inside UI
    components, route handlers or server actions. For each one:
    - quote the lines
    - name the rule in plain words
    - suggest a pure function name and signature to move it into (no framework imports)
    - show how the component or handler would call it
    
    Do not suggest moving simple display formatting.

    Example input

    function CartTotal({ items, user }) { const total = items.reduce((s, i) => s + i.price * i.qty, 0); const discount = user.plan === 'pro' && total > 100 ? total * 0.1 : 0; return <p>{total - discount}</p>; }

    Example output (illustrative)

    Rule: pro users get 10% off orders over 100. Move to `cartTotal(items: Item[], plan: Plan): { total: number; discount: number }` in domain/pricing.ts; the component renders the result.

    Illustrative example (AI-generated); results vary with the model and your context.

    Tips

    Ask for the function signatures first, then the code: it keeps the refactor small.

    Node.js + Express API rules · Copilot instructions & Cursor rules

    Use case

    A REST API in Node.js with Express and TypeScript. Save as .github/copilot-instructions.md.

    Prompt

    # {project_name}: Express API (TypeScript)
    
    - Layering: routes -> handlers -> services -> repositories. Handlers never touch the database.
    - Validate every request body, query and params with {validation_library} at the route.
    - Errors: throw AppError(code, message, status); one error middleware formats { error: { code, message } }.
    - Never return stack traces or SQL errors to clients.
    - All SQL is parameterised. No string-built queries.
    - Every outbound HTTP call has a timeout.
    - Log with the shared logger, including requestId; never log request bodies on auth routes.
    - New endpoints get an integration test with {test_framework} + supertest.

    Example input

    Request in the editor: "Add an endpoint to update a user's email."

    Example output (illustrative)

    Generated code validates the body with a schema, calls usersService.updateEmail, and throws AppError('EMAIL_TAKEN', ..., 409) instead of returning a raw database error.

    Illustrative example (AI-generated); results vary with the model and your context.

    Tips

    List your layer names exactly as the folders are named.

    Prisma rules · Copilot instructions & Cursor rules

    Use case

    Projects using Prisma ORM. Save as .cursor/rules/prisma.mdc.

    Prompt

    ---
    description: Prisma query and schema conventions
    globs: **/*.ts, prisma/schema.prisma
    alwaysApply: false
    ---
    - One PrismaClient instance, imported from {client_path}.
    - Use select or include deliberately; never return full records with password or token fields.
    - Use prisma.$transaction for multi-step writes.
    - Avoid queries in loops; use findMany with where: { id: { in: ids } }.
    - Schema changes go through prisma migrate dev; no db push in shared environments.
    - Add @@index for fields used in where and orderBy on large tables.

    Example input

    Request in the editor: "Load posts with their author names."

    Example output (illustrative)

    Generated query uses select with author: { select: { name: true } } instead of including the whole user record.

    Illustrative example (AI-generated); results vary with the model and your context.

    Tips

    The no-full-records rule prevents accidental password-hash leaks.

    Fix an N+1 query problem · DevOps, Docker, Kubernetes & SQL tuning

    Use case

    Remove the query-per-row pattern from ORM code.

    Prompt

    This {orm} code runs one query per item:
    
    {code}
    
    Show the fixed version that loads everything in a constant number of queries (eager loading, a join, or an
    IN query with a lookup map). Then tell me how to confirm the fix by counting queries in a test or the logs.

    Example input

    posts = Post.all(); for p in posts: print(p.author.name)

    Example output (illustrative)

    posts = Post.objects.select_related('author'). Confirm with assertNumQueries(1) in a test.

    Illustrative example (AI-generated); results vary with the model and your context.

    Tips

    Turn on query logging in development; N+1 problems are obvious there.

    Plan a database major version upgrade · DevOps, Docker, Kubernetes & SQL tuning

    Use case

    Upgrade the database engine with a tested plan and a way back.

    Prompt

    Plan an upgrade of {database} from version {from_version} to {to_version} on {hosting}.
    
    Cover: breaking changes to check (tell me where to read the official release notes, do not list from memory as
    fact), extension compatibility, testing on a restored copy with the app's test suite, the upgrade method
    (in place, logical replication or dump/restore) with expected downtime, a rollback plan, and post-upgrade
    checks (statistics, slow queries, error logs).

    Example input

    Postgres 13 to 16 on a managed service, 120 GB.

    Example output (illustrative)

    Restore last night's snapshot to a test instance, upgrade it, run the test suite and the top 20 queries, and compare timings. Production: use the provider's in-place upgrade in a maintenance window, after a manual snapshot (the snapshot is the rollback).

    Illustrative example (AI-generated); results vary with the model and your context.

    Tips

    Always rehearse on a restored copy and time it; the rehearsal tells you the real downtime.

    Turn a blog post into a tutorial outline · Content & developer marketing

    Use case

    Restructure an opinion or overview post into a step-by-step tutorial.

    Prompt

    You are a technical editor. Turn this blog post into a tutorial outline for {audience}:
    
    {post}
    
    Output: title, what the reader builds, prerequisites, 5-9 numbered steps (each with the goal, the code or
    command to show, and how to check it worked), common errors, and next steps.
    Rules: plain words, short sentences, no hype words (revolutionary, game-changing, unlock, supercharge).
    Do not invent numbers, benchmarks, customer names or quotes; mark anything that needs a real figure as [ADD DATA].
    Keep code and commands exactly as given.

    Example input

    A post about why you moved background jobs from cron to a queue.

    Example output (illustrative)

    Title: Move cron jobs to a queue in Node.js. Step 1: list current cron jobs and their schedules (check: a table of jobs). Step 2: add the queue library ...

    Illustrative example (AI-generated); results vary with the model and your context.

    Tips

    Give the audience level; a tutorial for juniors needs more steps.

    Version Changelog

    v1.02026-11-07

    150 prompts.

    Product FAQ & Licensing

    What is included in the AI Prompt Engineering Pack?

    It includes 50 architecture, refactoring and security audit prompts for Claude and GPT-4o, 40 inline .github/copilot-instructions.md and Cursor rules templates, 30 DevOps, Dockerfile, Kubernetes and SQL performance tuning prompts, and 30 content creator and developer marketing prompts covering code to blog to YouTube to Reels.

    Which AI tools does this pack work with?

    The prompts and templates are written for Copilot, Claude and ChatGPT, including GPT-4o. The instruction templates target repository-level setups such as .github/copilot-instructions.md and Cursor rules.

    Is this for beginner developers?

    It is positioned for senior developers and teams who already review and ship code. The prompts assume familiarity with architecture, refactoring, SQL tuning and DevOps practices.

    When will the pack be available?

    The pack is currently marked as coming soon. Check the product page for availability updates before purchasing.