DeepSeek V4 Flash Prompt Generator

Design a production-ready system prompt for an AI agent with the following specification: Agent name: [name] Agent role: [e.g. customer support, code reviewer, research assistant] Capabilities available: [list tools/APIs the agent can call] Constraints: [things the agent must never do] Output format: [how responses should be structured] Tone: [formal / casual / technical] The system prompt must: 1. Open with a role definition in one sentence 2. List capabilities explicitly with when to use each 3. Define escalation rules (when to refuse or hand off) 4. Specify output format with an example 5. Include 3 guardrails as numbered rules 6. Close with a decision checklist the agent runs before every response Output the full system prompt, ready to paste into an API call.

Refactor the following code across multiple files to improve readability, performance, and maintainability. Language / framework: [e.g. TypeScript / Next.js 15] Refactor goals: - [ ] Reduce duplication - [ ] Improve type safety - [ ] Split large functions (target: max 40 lines each) - [ ] Apply [pattern — e.g. repository pattern, dependency injection] Files: ``` [Paste all files here — DeepSeek V4 Flash handles 1M tokens] ``` Deliver: 1. Each refactored file with filename headers 2. A diff summary — what changed and why for each file 3. Any breaking changes that callers need to update 4. One-paragraph rationale for the main structural decision

Execute this multi-step coding task as an agent. State your plan before starting. After each step, confirm what you produced and what comes next. Goal: [describe the end result — e.g. 'Add OAuth2 login to this Express app'] Codebase context: ``` [Paste relevant files] ``` Tools you may simulate: - File read/write - Terminal command execution - Web search (describe what you'd search) After completing all steps: 1. List every file created or modified 2. Write the test command to verify it works 3. Describe any assumptions you made that a human should verify

Systematically find every bug in this codebase. For each bug, provide a severity rating and a ready-to-apply fix. Language: [e.g. Python 3.12] Test suite (if any): ``` [Paste tests] ``` Code to audit: ``` [Paste code — or paste the entire repo] ``` For each bug found: - File and line number - Bug classification (logic error / null dereference / race condition / off-by-one / etc.) - Severity: CRITICAL / HIGH / MEDIUM / LOW - Exact fix (show the corrected code block) - Why this bug exists (root cause in one sentence) End with: the 3 highest-priority bugs to fix first, and the systemic pattern causing most of them.

Design the tool-use chain for an AI agent that must complete the following task: Task: [describe what the agent must accomplish end-to-end] Available tools: - [tool_name]: [description and parameters] - [tool_name]: [description and parameters] - [tool_name]: [description and parameters] Deliver: 1. A numbered sequence of tool calls with the exact parameters for each step 2. What each tool call is checking or producing 3. The branching logic — what happens if a tool returns an error or unexpected output 4. The stopping condition — how the agent knows the task is complete 5. A pseudo-code loop showing the full agentic flow Format the tool calls as JSON objects ready to include in a Responses API payload.

Generate a comprehensive unit test suite for the following code. Framework: [e.g. Jest / Pytest / Vitest / Go testing] Code to test: ``` [Paste the function, class, or module] ``` Test coverage requirements: - All happy paths - All edge cases (empty input, null, zero, max value, unicode) - All error paths (exceptions, invalid types, network failure simulation) - Any async behaviour (promises, callbacks, goroutines) For each test: - A descriptive test name explaining what is being verified - Arrange / Act / Assert structure - Mock setup for any external dependencies End with: a coverage gap analysis — what this suite still doesn't test and why it's hard to test.

Scaffold a production-ready REST API for the following specification. Framework: [e.g. FastAPI / Express / Hono / Go Fiber] Entities: [list the data models — e.g. User, Order, Product] Auth: [bearer token / API key / OAuth2 / none] Database: [e.g. PostgreSQL with SQLAlchemy / Prisma / Drizzle] Deliver: 1. Directory structure (file tree) 2. Full code for each file — models, routes, controllers, middleware 3. OpenAPI 3.1 schema for every endpoint 4. Environment variable list (.env.example) 5. Docker Compose file (app + database) 6. curl examples for each endpoint

Design a complete CI/CD pipeline for the following project. Stack: [e.g. Next.js 15 deployed to Vercel / Python FastAPI on AWS ECS] CI platform: [GitHub Actions / GitLab CI / CircleCI] Environments: [dev / staging / production] Requirements: - Run tests on every pull request - Block merge if coverage drops below [X]% - Deploy to staging on merge to main - Deploy to production on manual approval - Notify [Slack / email] on failure Deliver: 1. The full YAML pipeline file(s) 2. Required secrets and where to set them 3. The rollback procedure if production deploy fails 4. Estimated pipeline runtime and how to speed it up

Write an error recovery protocol for an AI agent that must complete long-running tasks without human intervention. Agent task type: [describe what the agent does — e.g. 'processes incoming customer support tickets and routes them'] Possible failure modes: - [failure mode 1] - [failure mode 2] - [failure mode 3] For each failure mode, define: 1. Detection — how the agent identifies this failure 2. Immediate action — what the agent does in the next 30 seconds 3. Retry strategy — how many times, with what backoff 4. Escalation rule — when to stop retrying and alert a human 5. State preservation — what data to save before stopping Output as a decision tree the agent can execute programmatically.

Optimise these database queries for maximum performance. Database: [PostgreSQL / MySQL / SQLite / MongoDB] Table sizes: - [table_name]: ~[row count] - [table_name]: ~[row count] Existing indexes: [list them] Queries to optimise: ```sql [Paste your slow queries] ``` For each query: 1. Identify the performance bottleneck (missing index / N+1 / full scan / etc.) 2. Rewrite the query for maximum speed 3. Add any required index definitions (exact CREATE INDEX statements) 4. Estimate the speedup (rough order of magnitude) End with: a ranked list of the top 3 changes by expected impact.

Write a clear, complete pull request description for the following code change. Repo context: [describe the project in one sentence] Branch purpose: [what this PR accomplishes] Files changed: ``` [Paste git diff or list of changed files with brief notes] ``` The PR description must include: 1. **Summary** — 2-3 bullet points: what changed and why 2. **How to test** — step-by-step verification instructions 3. **Screenshots** — placeholders marked [SCREENSHOT: description] 4. **Related issues** — format: Closes #[issue number] 5. **Breaking changes** — yes/no, and if yes what callers must update 6. **Checklist** — tests added, docs updated, migration needed Tone: professional, precise. No padding.

Create a step-by-step migration guide to upgrade this codebase from [old version / framework] to [new version / framework]. Current stack: ``` [Paste package.json / pyproject.toml / go.mod or equivalent] ``` Key files (paste the most important ones): ``` [Paste code] ``` Migration guide must include: 1. Pre-migration checklist (what to verify before starting) 2. Step-by-step instructions in order — each step is one terminal command or one file edit 3. Breaking changes and how to adapt each one 4. How to verify each step succeeded before proceeding 5. Rollback procedure for each step 6. Estimated time for a solo developer Flag any step that requires a production deployment window.

Perform a security audit of the following code. Classify every vulnerability by OWASP category and CVSS severity. Code: ``` [Paste the codebase — or the specific module to audit] ``` Audit scope: - Injection (SQL, command, LDAP) - Broken authentication and session management - Sensitive data exposure (hardcoded secrets, weak encryption) - Insecure direct object references - Security misconfiguration - Cross-site scripting (XSS) - Insecure deserialization - Missing access control For each vulnerability: - Location (file:line) - OWASP category - CVSS score (estimate) - Attack scenario in one sentence - Exact remediation code End with: a remediation priority list (fix these first or ship nothing).

Write complete documentation for the following code module. Audience: [e.g. external API consumers / internal developers / open-source contributors] Code: ``` [Paste functions, classes, or module] ``` Documentation must include: 1. **Overview** — what this module does in 2 sentences 2. **Installation** — setup steps from zero 3. **Quick start** — the simplest working example (copy-paste ready) 4. **API reference** — every public function/method: signature, parameters, return value, one example 5. **Error reference** — every error type the code raises with cause and fix 6. **FAQ** — 4 questions a new user would ask Format: Markdown. Use real code examples, not pseudocode.

Design a multi-agent system where several DeepSeek V4 Flash agents collaborate to complete the following task. Task: [describe the overall goal] Decomposition: - Agent A role: [e.g. researcher — gathers information] - Agent B role: [e.g. writer — drafts the output] - Agent C role: [e.g. critic — reviews and scores the draft] - Agent D role (optional): [orchestrator / QA checker] For each agent, provide: 1. Their system prompt (full, ready to use) 2. What input they receive 3. What output they produce 4. How they hand off to the next agent Also provide: the orchestrator loop in pseudo-code showing how to wire agents A→B→C together and what the final output looks like.

Audit the following codebase for technical debt. Quantify each item by remediation cost and business risk. Codebase: ``` [Paste code or repo contents] ``` For each debt item: - Location (file or module) - Debt type: architectural / code quality / dependency / documentation / test coverage - Root cause (one sentence) - Risk if unaddressed: HIGH / MEDIUM / LOW with reasoning - Estimated remediation effort: [hours/days] - Recommended fix End with: 1. A sorted payoff matrix (highest risk × lowest cost first) 2. The 3 debt items to fix in the next sprint 3. The 2 items to schedule for next quarter 4. Anything that should be a full rewrite (be honest)

Write a Codex-compatible agent task prompt for the following software engineering objective. Objective: [describe what you want the agent to build or fix] Repo context: [brief description of the project] Constraints: - Language/framework: [specify] - Must not modify: [list protected files] - Must pass: [describe the test command — e.g. 'npm test'] - PR must include: [description, tests, updated docs] Format the task as a Codex task.yaml with: - task_description - acceptance_criteria (list of checkable conditions) - repo_context - starting_point (the file or function to begin from) - suggested_approach (3-step plan) Also write the human-readable version of the same task as a GitHub issue body.

Help me decide between these architectural approaches for the following system. System: [describe what you're building — one paragraph] Scale targets: [users, requests/sec, data volume at 1× and 10× growth] Team: [number of engineers, their primary expertise] Options to compare: - Option A: [describe] - Option B: [describe] - Option C: [describe or omit] Deliver: 1. A weighted trade-off matrix scoring each option on: latency, reliability, cost, operational complexity, team fit, and time-to-ship 2. Your recommendation with a clear rationale 3. The single strongest argument AGAINST your recommendation 4. The first proof-of-concept experiment to validate the key assumption before committing 5. What this decision looks like in 2 years if you're right vs wrong

Profile and diagnose performance issues in the following code. Language / runtime: [e.g. Node.js 22 / Python 3.12 / Go 1.23] Observed symptoms: [e.g. 'p99 latency spikes to 4s under 500 RPS', 'memory grows 50MB/hour'] Relevant code: ``` [Paste the hot path — the code executing most often] ``` Deliver: 1. Hypotheses ranked by likelihood with one-line reasoning each 2. For the top hypothesis: the exact profiling command to confirm it 3. The fix — specific code changes, not vague advice 4. Expected improvement (order of magnitude) 5. How to prevent this class of issue in future (one architectural rule) If you need more information to diagnose, list exactly what to collect.

Design a prompt chain where DeepSeek V4 Flash processes a complex task in sequential steps, each building on the previous output. Final goal: [describe the end deliverable] Input available: [describe the raw material — document, dataset, codebase, etc.] Design a chain of exactly [4–6] prompts where: - Prompt 1: extracts or structures the raw input - Prompt 2: analyses or transforms the structured data - Prompt 3: generates the first draft of the output - Prompt 4+: refines, critiques, or expands - Final prompt: formats the output exactly as needed For each prompt in the chain: 1. Write the full prompt text (copy-paste ready) 2. Describe the expected output format 3. Explain what this step adds that the previous step couldn't Also describe: how to run this chain programmatically using the DeepSeek API with the Responses API format.