AI Coding Assistant Setup

How It Works

Describe the languages and frameworks you use, your editor, the kind of work (features, bugs, refactors, scripts), and your experience level. The guide gives you the precise setup steps, rules files or instructions to paste, a library of prompts for the most common coding tasks, a safe workflow that includes verification, and how to review AI suggestions so you stay in control.

What to Provide

Coding Assistant Blueprint

Replace [[tokens]]. This is the complete setup deliverable.

1. Tool Stack Recommendation

Primary AI coding environment: [[Cursor (recommended for most) or VS Code + Copilot + Claude in sidebar or Aider in terminal]]

Why for your mix: [[Fast inline edits + strong reasoning models + project context + rules files]]

Supporting tools:

• Reasoning / planning: [[Claude Sonnet 5 or high-reasoning tier in chat or Cursor composer]]
• Quick lookup / docs: [[Perplexity or the model's browse if available]]
• Terminal agent (optional): [[Aider or Continue.dev]]
• Review: [[GitHub PR + human or AI review prompt]]

Cost: [[Cursor Pro ~$20/mo pays for itself in hours saved]]

2. Project Rules and Context (Most Important Setup Step)

Create a file in your repo root called [[.cursorrules or AGENTS.md or CLAUDE.md]] and paste the following (customize):

You are an expert [[language + framework]] developer on this codebase.

Style & conventions:
- Follow the existing patterns in the repo exactly.
- Use [[TypeScript strict / Python type hints / our ESLint config]].
- Prefer [[composition over inheritance, small functions, early returns]].
- Naming: [[camelCase for vars, Pascal for components, descriptive]].

Architecture notes:
- [[Frontend lives in /app, API routes in /api, shared types in /types]]
- [[Auth is handled via [[middleware or context]]]]
- [[Data access goes through [[repository / service layer]]]]

Testing:
- Unit tests use [[Vitest / Jest / pytest]].
- Place tests next to the file or in __tests__.
- Cover happy path + at least one edge case for new logic.

Security & performance:
- Never log secrets or PII.
- Validate all external input.
- Prefer efficient queries; explain any N+1 risk.

When asked to make a change:
1. First summarize the plan in 3–5 bullets.
2. Make the smallest change that achieves the goal.
3. Include or update tests when behavior changes.
4. After edits, suggest the command to run to verify.

Never introduce new dependencies without asking.

Update this file whenever your conventions or architecture changes. The AI will read it automatically in supporting tools.

3. Daily Workflow

Starting a new feature or ticket:

1. Paste the ticket description + acceptance criteria into the AI chat or composer.
2. Ask: "Give me a minimal plan with files touched and risks."
3. Iterate on the plan until it is small and safe.
4. Let the AI implement one file or logical chunk at a time.
5. Run the app + tests after each chunk.
6. Review every diff yourself before commit.

Bug fix workflow:

1. Paste the error + stack trace + relevant code.
2. Ask: "Reproduce steps + root cause hypothesis + minimal fix."
3. Apply fix + add or update a regression test.
4. Verify the original reproduction no longer fails.

Refactor workflow:

1. State the goal ("make this 30% clearer and remove duplication").
2. Ask for a before/after summary of changes.
3. Do it in small, reviewable steps.
4. Run full test suite or type check before merging.

Code review of AI changes:

• Read every line.
• Check for the rules in your .cursorrules file.
• Ask the AI "what could go wrong with this change in production?" and address the answers.
• Add comments for non-obvious decisions.

4. Prompt Library for Common Coding Tasks

Prompt: Plan a feature

"Here is the ticket: [[paste]]

Current relevant files: [[list or paste key functions]]

Give me:
1. 3–5 bullet implementation plan (smallest safe steps)
2. Files that will change
3. Any data model or API changes
4. Test strategy
5. Risks and how we will mitigate them"

Prompt: Implement one step

"Implement only step [[X]] from the plan. Follow the project rules file exactly. Show the diff or the new code. After, tell me the exact command to run to test this piece."

Prompt: Debug

"Error: [[full message + stack]]

Relevant code: [[paste]]

Reproduce the bug with a minimal failing case if possible. Then give the root cause in one sentence and the smallest fix."

Prompt: Write or improve tests

"Write [[unit / integration]] tests for [[the function or component]].

Use [[our test framework]].

Cover: happy path, [[edge 1]], [[edge 2]], error case.

Place the test file next to the source per our convention."

Prompt: Explain code (for learning or onboarding)

"Explain this code to a [[mid-level developer new to the codebase]].

First give the 30-second mental model.

Then walk through the main flow line by line or block by block.

Highlight any clever or non-obvious parts and why they exist.

End with 'What I would ask if I were reviewing this PR'."

5. Verification and Safety Habits

Non-negotiable before any AI change ships:

1. You understand every line.

<blank line between>

1. Type check / lint passes.

<blank line between>

1. Relevant tests pass (or new tests added and passing).

<blank line between>

1. Manual smoke of the user flow on your machine.

<blank line between>

1. Check for secrets or hard-coded values.

When the AI suggests something you do not understand:

• Ask it to explain.
• Ask for a smaller version.
• Look up the API or pattern yourself.
• Do not merge what you cannot explain in a PR description.

Rate limiting your own speed:

AI makes you fast. Slow down on anything touching money, auth, data migration, or external APIs. One extra 10-minute review saves hours later.

6. 14-Day Ramp-Up Plan

Days 1–3: Install chosen tool. Create the rules file. Set up one project. Do 3 small real tasks end-to-end using the plan-then-implement pattern.

Days 4–7: Use AI for all new code and one refactor. Track time. Aim for 30–50% time saved on mechanical work while maintaining quality.

Days 8–14: Add test generation and review prompts to your flow. Create 2–3 of your own prompt templates from things that worked well. Update the rules file with anything you learned about your codebase.

Worked Examples

Example 1: Mid-Level TS/React Developer (Cursor)

Setup: Cursor + Claude Sonnet 5 + project rules file.

Daily: Paste ticket → plan → implement file by file → run tests in terminal inside Cursor → review diff.

Result: Shipping small features in half the previous time; fewer bugs because tests are written alongside.

Example 2: Python Backend Engineer (Aider + Claude)

Setup: Terminal + Aider + repo rules.

Flow: /add file → describe change → watch edits → run pytest in same session.

Result: Big refactors that used to take days now planned and executed in hours with full test coverage.

Example 3: Junior Developer Learning (VS Code + Copilot + Chat)

Setup: Copilot for autocomplete + separate Claude chat for explanations.

Rule: Never accept a suggestion without reading and understanding. Use "explain" prompt on every new pattern.

Result: Learning velocity 2–3x previous self-study; code reviews pass with fewer style comments.

Format Checklist

Final Rule

The AI is a very fast, very knowledgeable pair programmer who never gets tired. You are still the senior engineer on the change. Keep that mindset and you will move extremely fast without accumulating technical debt.

Set up the rules file and first prompt today. You will feel the difference on the very next ticket.