Everything you plug TDSPRO into

A complete, responsive marketing page from one description.

You are a senior frontend engineer. Build a modern, responsive landing page for the product below.

Product: <describe your product in one or two sentences>
Audience: <who is it for>
Vibe: clean, premium, trustworthy.

Requirements:
- A single self-contained page (HTML + CSS, or React + Tailwind if the project already uses it).
- Sections: hero with a clear headline and CTA, 3-feature grid, social-proof strip, pricing or sign-up block, footer.
- Mobile-first and accessible (semantic tags, good contrast, focus states).
- No lorem ipsum — write real, concise marketing copy.

Return the full code in one block, then a short list of what to tweak next.

Find the root cause, then a minimal, safe fix.

Act as a careful debugging partner. I have a bug.

Symptom: <what goes wrong>
Expected: <what should happen>
Code / file:
```
<paste the relevant code>
```
Error / logs (if any):
```
<paste the error>
```

Steps:
1. State the most likely root cause and why (don't guess wildly).
2. Show the smallest correct fix as a diff.
3. List 1-2 edge cases the fix should also cover.
Do not refactor unrelated code.

Cover the important paths, not just the happy one.

Write tests for the code below.

Code:
```
<paste the function or module>
```
Test framework: <e.g. Vitest / Jest / Pytest — or pick the project's one>

Requirements:
- Cover the happy path, edge cases, and at least one failure case.
- Use clear, descriptive test names.
- Mock external calls; tests must be deterministic and fast.
- No network or real I/O.

Return only the test file, ready to run, plus a one-line note on anything left untested.

Cleaner and clearer — without changing behaviour.

Refactor the code below for readability and maintainability.

Code:
```
<paste the code>
```

Rules:
- Keep behaviour identical — no functional changes.
- Improve naming, remove duplication, simplify control flow, add types where helpful.
- Keep the public API the same unless I explicitly allow a change.
- Explain each meaningful change in one short line.

Return the refactored code, then the change list.

Understand an unfamiliar file fast.

Explain the code below as if to a competent developer new to this project.

Code:
```
<paste the code>
```

Cover:
1. What it does, in 2-3 sentences.
2. A walk-through of the key parts, top to bottom.
3. Any non-obvious behaviour, gotchas, or assumptions.
4. One question I should ask the author before changing it.

Be concrete and concise. No filler.

Plan first, then implement — fitting your codebase.

Add a feature to my project. Plan before you code.

Feature: <describe what it should do>
Stack / context:
```
<paste relevant files or describe the structure>
```

Do this:
1. Propose a short plan (files to touch, new functions, data flow).
2. Wait — actually, go ahead and implement it, matching the existing style and conventions.
3. Show the full changes as diffs.
4. Note anything I need to do manually (migrations, env vars, installs).
Keep it minimal and consistent with the codebase.

A clear title and body a reviewer can approve fast.

Write a pull request description for the change below.

Diff / summary of changes:
```
<paste the diff or describe what changed>
```

Produce:
- A concise, imperative title (max ~70 chars).
- "What & why": 2-4 sentences on the change and the motivation.
- "How to test": exact steps a reviewer runs to verify it.
- "Risks / notes": anything to watch (migrations, breaking changes, follow-ups).
Keep it factual — no hype. Use short bullet points.

Catch bugs and risks before they ship.

Review this change like a careful senior reviewer. Bugs over style.

Diff:
```
<paste the diff>
```

Check, in order: correctness (null/async/off-by-one), edge cases, security (injection, authz, secrets in logs), simplicity, and missing tests.

Output findings grouped by severity (blocker / should-fix / nit). For each: file:line, what's wrong, and the concrete fix. Lead with blockers. If it's clean, say so plainly.

A production-ready API route with validation and errors.

Scaffold a new API endpoint, matching this project's framework and conventions.

Endpoint: <method + path, e.g. POST /api/orders>
Does: <what it should do>
Input: <body / query params>
Output: <success shape + status>

Requirements:
- Validate and sanitize all input; reject bad requests with clear 4xx errors.
- Handle the failure paths (not found, unauthorized, downstream error) explicitly.
- No secrets in responses or logs.
- Follow the existing file/route structure — show where the file goes.
Return the full handler plus a one-line curl to test it.

Remove what nothing uses — safely, with proof.

Find and remove dead code in the file/module below — safely.

Code / context:
```
<paste the code or describe the module>
```

Do this:
1. List each unused thing (function, export, import, branch, variable) and HOW you know it's unused (no references / unreachable).
2. Flag anything that only *looks* dead but might be used via reflection, dynamic import, public API, or tests — do NOT remove those; ask.
3. Show the cleaned code as a diff.
4. Note which tests / typecheck to run to confirm nothing broke.
Be conservative: when unsure, leave it and say why.

Measure first, then fix the real bottleneck.

Help me make this faster — measure before you optimise.

Code / scenario:
```
<paste the slow code and describe the workload>
```

Do this:
1. Identify the most likely bottleneck and WHY (algorithmic cost, N+1 queries, re-renders, sync I/O…). Don't micro-optimise the wrong thing.
2. Suggest how to measure it (which metric / tool) so we confirm before and after.
3. Propose the highest-impact change first, as a diff, keeping behaviour identical.
4. Note the trade-offs (memory, readability, complexity).
No premature optimisation — justify each change with the cost it removes.

A README that gets someone running in 5 minutes.

Write a clear README for this project.

Project:
```
<paste package.json / file tree / a short description>
```

Include, in this order:
- One-line description of what it is and who it's for.
- Quick start: install, configure (env vars), run — exact commands.
- Key features, briefly.
- Project structure (only the folders that matter).
- Common scripts / commands.
- License line.
Plain language, no marketing fluff. Use real commands, not placeholders, where you can infer them.