@shaykec/bridge 0.4.24 → 0.4.26

package/modules/ai-pair-programming/content.md

@@ -0,0 +1,105 @@
+# AI Pair Programming — Working with Claude Code
+
+<!-- hint:slides topic="AI pair programming: mental model, when AI helps vs struggles, prompting patterns, and the human-AI feedback loop" slides="5" -->
+
+## Mental Model
+
+Think of AI as a pair programmer: fast, knowledgeable, but without full context of your codebase, conventions, or constraints. You steer; the AI proposes. You verify; the AI iterates.
+
+## When AI Helps vs When It Doesn't
+
+### AI Excels At
+- **Boilerplate** — repetitive setup, configs, scaffolding
+- **Translating intent** — "add validation for email format" → code
+- **Explaining** — "what does this regex do?"
+- **Exploring options** — "show me three ways to implement X"
+- **Fixing known patterns** — common bugs, linter fixes
+
+### AI Struggles With
+- **Project-specific context** — your naming, architecture, existing patterns
+- **Live state** — what's running, current errors, env vars
+- **Ambiguity** — "make it better" (better how?)
+- **Multi-file refactors** — keeping the whole system consistent
+- **Creative design** — you know the product; AI infers
+
+## Effective Prompting Patterns
+
+### Be Specific
+❌ "Fix this function."  
+✅ "This function should return null when `input` is empty; it currently throws. Also add a JSDoc."
+
+### Provide Context
+❌ "Write a React component."  
+✅ "Write a React component for a user avatar. We use Tailwind, and `user` has `name` and `avatarUrl`. Match the pattern in `ProfileCard.jsx`."
+
+### Show Examples
+❌ "Use our API style."  
+✅ "Follow this pattern: `const { data, error } = useApi('/users');` — same hook, different endpoint."
+
+### Break Down Large Tasks
+❌ "Build a full auth flow."  
+✅ "Step 1: Add a login form component. Step 2: Wire it to the existing `auth.login` function. Step 3: Add error handling for invalid credentials."
+
+## Iterating on Output
+
+1. **Run and verify** — don't assume it works; run tests, try the flow
+2. **Narrow feedback** — "The `fetch` URL is wrong; it should use `API_BASE` from config"
+3. **Escalate gradually** — if the AI keeps missing, add more context or take over that part
+
+## Reviewing AI-Generated Code
+
+Treat it like any code review:
+
+- **Correctness** — does it do what you asked?
+- **Safety** — no hardcoded secrets, proper input validation
+- **Fit** — matches your patterns, conventions, architecture
+- **Maintainability** — clear, readable, not over-engineered
+
+```javascript
+// AI might produce this:
+const key = "sk-12345";  // ❌ Never commit secrets
+
+// You ensure:
+const key = process.env.API_KEY;  // ✅ From env
+```
+
+## Claude Code Features
+
+### Skills
+Skills are reusable procedures. If your task matches a skill, invoke it: the agent follows the skill's steps. Example: `spec-writer`, `argus-integration`.
+
+### Subagents
+Heavy or parallel work can be delegated. The main agent coordinates; subagents focus on specific batches (e.g., screen customization, testing).
+
+### MCP (Model Context Protocol)
+Tools like Argus (testing), appxray (inspection), code search. Enable the right MCP for your task so the agent can inspect, test, and validate.
+
+## When to Take Over Manually
+
+- **Subtle bugs** — AI keeps proposing wrong fixes; you know the cause
+- **Architecture decisions** — you own the design
+- **Sensitive logic** — auth, billing, security-critical paths
+- **Performance** — AI may not know your bottlenecks
+
+## Human-AI Collaboration Loop
+
+```mermaid
+flowchart LR
+    A[You: goal + context] --> B[AI: proposal]
+    B --> C{You: verify}
+    C -->|Pass| D[Ship it]
+    C -->|Fail| E[You: specific feedback]
+    E --> B
+```
+
+The loop tightens when feedback is **specific** and **iterative**. "Try again" rarely helps; "use `useCallback` here because the parent re-renders often" does.
+
+---
+
+## Key Takeaways
+
+1. **You're the architect** — AI implements; you verify and integrate
+2. **Context is king** — the more you give, the better the output
+3. **Iterate with precision** — narrow, concrete feedback beats vague "fix this"
+4. **Review everything** — AI code can have subtle bugs and security issues
+5. **Know when to take over** — some work is yours to do

package/modules/ai-pair-programming/exercises.md

@@ -0,0 +1,98 @@
+# AI Pair Programming Exercises
+
+## Exercise 1: Improve a Vague Prompt
+
+**Task:** Someone gave Claude Code this prompt: "Add tests for the user service." Rewrite it to be specific enough for useful output. Include: what to test, which file/module, and any existing test patterns.
+
+**Validation:**
+- [ ] Specifies the module/class/service under test
+- [ ] Mentions what to test (e.g., happy path, error cases)
+- [ ] References existing test style if applicable (e.g., Jest, Vitest)
+
+**Hints:**
+1. "User service" — which file? Which functions?
+2. What behaviors matter? Create, update, validation errors?
+3. "We use Vitest and `describe`/`it`" — pattern matters
+
+---
+
+## Exercise 2: Provide Context via Example
+
+**Task:** Your API client uses a specific pattern for auth headers. Write a 3-sentence prompt that shows the pattern so the AI can add a new authenticated request.
+
+Pattern: `headers: { 'Authorization': `Bearer ${token}` }` and token from `getAuth().token`.
+
+**Validation:**
+- [ ] Includes a concrete example of the header format
+- [ ] Explains where the token comes from
+- [ ] Specifies the new endpoint or use case
+
+**Hints:**
+1. Show one real request that uses the pattern
+2. Name the auth helper or context
+3. State the new endpoint or action needed
+
+---
+
+## Exercise 3: Give Narrow Feedback
+
+**Task:** The AI produced a 50-line component with a bug: it doesn't handle the loading state. The loading prop exists but isn't used. Write feedback that fixes just this, without asking for a full rewrite.
+
+**Validation:**
+- [ ] Identifies the exact issue (loading state unused)
+- [ ] Suggests where/how to use it (e.g., show spinner when loading)
+- [ ] Doesn't ask for unrelated changes
+
+**Hints:**
+1. Point to the prop: "The `loading` prop is passed but never used"
+2. Suggest the fix: "Show a spinner when loading is true"
+3. Optionally show a one-line example
+
+---
+
+## Exercise 4: Review AI Output for Security
+
+**Task:** The AI suggested this code for a "forgot password" flow:
+
+```javascript
+async function resetPassword(email, newPassword) {
+  await fetch('/api/reset', {
+    method: 'POST',
+    body: JSON.stringify({ email, newPassword })
+  });
+}
+```
+
+List three security or correctness issues and how you'd fix them.
+
+**Validation:**
+- [ ] Identifies at least: HTTPS, token/verification, plaintext password
+- [ ] Proposes concrete fixes (e.g., token-based flow, hash on server)
+
+**Hints:**
+1. Is the password sent in plaintext? How should reset work?
+2. Does the API verify the requester? Token in email link?
+3. HTTPS, rate limiting, validation?
+
+---
+
+## Exercise 5: Decide AI vs Manual
+
+**Task:** For each scenario, choose AI / Manual / Both and write one sentence justifying your choice.
+
+1. Refactor a 200-line function into smaller functions
+2. Fix a build error: "Module not found: './utils'"
+3. Design the data model for a new feature
+4. Write integration tests for an existing API
+
+**Validation:**
+- [ ] Refactor: Both (AI can suggest structure; you verify logic)
+- [ ] Build error: Manual (path/config is project-specific)
+- [ ] Data model: Manual or Both (design is yours; AI can draft)
+- [ ] Integration tests: Both (AI can scaffold; you verify coverage)
+
+**Hints:**
+1. Refactoring needs your domain knowledge but benefits from AI suggestions
+2. Module resolution is often path/casing/config — very project-specific
+3. Design decisions are architectural — you own them
+4. Tests: AI can generate structure; you ensure they test the right things

package/modules/ai-pair-programming/module.yaml

@@ -0,0 +1,39 @@
+slug: ai-pair-programming
+title: "AI Pair Programming — Working with Claude Code"
+version: 1.0.0
+description: "Use Claude Code effectively — prompting, iteration, and when to lean on AI vs code yourself."
+category: claude-code
+tags: [ai, claude-code, pair-programming, productivity, prompting]
+difficulty: intermediate
+
+xp:
+  read: 15
+  walkthrough: 40
+  exercise: 25
+  quiz: 20
+  quiz-perfect-bonus: 10
+
+time:
+  quick: 5
+  read: 20
+  guided: 50
+
+prerequisites: [code-review]
+related: [prompt-engineering, debugging-systematically]
+
+triggers:
+  - "How do I use Claude Code effectively?"
+  - "What's the best way to pair program with AI?"
+  - "How do I give good instructions to Claude Code?"
+  - "When should I use AI vs code myself?"
+
+visuals:
+  diagrams: [diagram-mermaid, diagram-flow]
+  quiz-types: [quiz-matching, quiz-timed-choice]
+  playground: bash
+  slides: true
+
+sources:
+  - url: "https://docs.anthropic.com"
+    label: "Anthropic Claude Documentation"
+    type: docs

package/modules/ai-pair-programming/quick-ref.md

@@ -0,0 +1,58 @@
+# AI Pair Programming Quick Reference
+
+## When AI Excels vs Struggles
+
+| AI Excels At | AI Struggles With |
+|--------------|-------------------|
+| Boilerplate, configs, scaffolding | Project-specific context |
+| Translating intent → code | Live state, env vars |
+| Explaining code | Ambiguity ("make it better") |
+| Exploring options | Multi-file refactors |
+| Fixing known patterns | Creative design |
+
+## Effective Prompting
+
+| Principle | Bad | Good |
+|-----------|-----|------|
+| Be specific | "Fix this function." | "Return null when `input` is empty; add JSDoc." |
+| Provide context | "Write a React component." | "Avatar component, Tailwind, `user.name` / `avatarUrl`, match `ProfileCard.jsx`." |
+| Show examples | "Use our API style." | "Follow: `useApi('/users')` — same hook, different endpoint." |
+| Break down tasks | "Build full auth flow." | "Step 1: Login form. Step 2: Wire to `auth.login`. Step 3: Error handling." |
+
+## Iterating on Output
+
+1. **Run and verify** — don't assume; run tests, try the flow
+2. **Narrow feedback** — "The `fetch` URL should use `API_BASE` from config"
+3. **Escalate** — if AI keeps missing, add context or take over
+
+## Code Review Checklist
+
+- [ ] **Correctness** — does it do what you asked?
+- [ ] **Safety** — no hardcoded secrets, proper validation
+- [ ] **Fit** — matches patterns, conventions, architecture
+- [ ] **Maintainability** — clear, readable, not over-engineered
+
+## When to Take Over
+
+- Subtle bugs AI can't fix after 2–3 tries
+- Architecture decisions
+- Sensitive logic (auth, billing, security)
+- Performance-critical paths
+
+## Claude Code Features
+
+| Feature | Purpose |
+|---------|---------|
+| **Skills** | Reusable procedures (spec-writer, argus-integration) |
+| **Subagents** | Parallel work; main agent coordinates |
+| **MCP** | Tools: Argus, appxray, code search |
+
+## Human–AI Loop
+
+```
+You: goal + context → AI: proposal → You: verify
+         ↑                                ↓
+         └── specific feedback ───────────┘
+```
+
+**Key:** "Try again" rarely helps. "Use `useCallback` here because the parent re-renders often" does.

package/modules/ai-pair-programming/quiz.md

@@ -0,0 +1,73 @@
+# AI Pair Programming — Quiz
+
+## Question 1
+
+When is AI *least* effective at helping?
+
+A) Writing boilerplate and config files
+B) Fixing a subtle race condition in WebSocket handling
+C) Explaining what a regex does
+D) Exploring multiple implementation options
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Subtle debugging involves project-specific state, timing, and environment. AI lacks live context and may propose wrong fixes. Boilerplate, explanation, and option exploration are AI strengths. -->
+
+## Question 2
+
+What makes a prompt more effective?
+
+A) Being short and generic
+B) Including context, examples, and specific requirements
+C) Using technical jargon only
+D) Asking for "better" or "improved" output
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Effective prompts provide context (where, what exists), examples (patterns to follow), and specific requirements. Vague prompts like "make it better" give the model little to work with. -->
+
+## Question 3
+
+The AI produced code that uses `var` and a `for` loop. You want `const` and `.map()`. What feedback works best?
+
+A) "Use modern JS"
+B) "Replace the for loop with .map() and use const instead of var"
+C) "Fix this"
+D) Rewriting the whole function yourself
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Narrow, concrete feedback tells the AI exactly what to change. "Use modern JS" is ambiguous; "Fix this" gives no direction. Rewriting bypasses the iteration loop. -->
+
+## Question 4
+
+When reviewing AI-generated code, you should check for:
+
+A) Only correctness
+B) Correctness, safety (no secrets, validation), fit (matches patterns), maintainability
+C) Only whether it runs
+D) Only style consistency
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Treat AI output like any code review. Correctness matters, but safety (hardcoded secrets, input validation), fit (conventions, architecture), and maintainability are equally important. -->
+
+## Question 5
+
+When should you take over from the AI manually?
+
+A) After the first iteration
+B) When the AI keeps proposing wrong fixes, or for architecture and security-critical decisions
+C) Never — always iterate until it works
+D) Only when the AI says it can't do something
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Diminishing returns from repeated iteration signals time to take over. Architecture, security-critical logic, and subtle bugs you understand are better handled manually. -->
+
+## Question 6
+
+What does a "skill" (e.g., spec-writer, argus-integration) provide that a freeform prompt doesn't?
+
+A) Faster response time
+B) A reusable procedure the agent follows step-by-step; standardized inputs and outputs
+C) Access to private APIs
+D) Lower cost per request
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Skills encode procedures. When invoked, the agent follows the skill's steps rather than interpreting a freeform request. This reduces ambiguity and ensures consistent results. -->

package/modules/ai-pair-programming/resources.md

@@ -0,0 +1,34 @@
+# AI Pair Programming — Resources
+
+## Official Docs
+
+- [Anthropic Claude Documentation](https://docs.anthropic.com) — Claude API, prompting, best practices.
+- [Claude Code Documentation](https://docs.anthropic.com/en/docs/build-with-claude/claude-code) — Claude Code setup and usage.
+
+## Videos
+
+- [How to Pair Program with AI](https://www.youtube.com/results?search_query=pair+program+AI) — Practical AI pairing workflows.
+- [Fireship — Claude Code](https://www.youtube.com/results?search_query=Fireship+Claude) — Quick Claude Code overview.
+- [Coding with AI Best Practices](https://www.youtube.com/results?search_query=coding+with+AI+best+practices) — Prompting and iteration.
+
+## Articles
+
+- [Anthropic — Prompt Engineering](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering) — How to write effective prompts.
+- [The Art of Prompting](https://simonwillison.net/series/prompting/) — Simon Willison on AI prompting.
+- [Anthropic — Working with Claude](https://docs.anthropic.com/en/docs/build-with-claude) — Effective AI collaboration and prompting.
+
+## Books
+
+- **The AI-Assisted Developer** by Nathan Young — Practical AI coding workflows.
+- **Prompt Engineering Guide** (various) — Prompt patterns and techniques.
+
+## Podcasts
+
+- [Software Engineering Daily](https://softwareengineeringdaily.com/) — Episodes on AI-assisted development.
+- [The Changelog](https://changelog.com/) — AI tools and pair programming discussions.
+
+## Tools
+
+- [Claude Code](https://claude.ai) — AI pair programmer from Anthropic.
+- [Cursor](https://cursor.com) — AI-first code editor.
+- [GitHub Copilot](https://github.com/features/copilot) — Inline AI suggestions.

package/modules/ai-pair-programming/walkthrough.md

@@ -0,0 +1,117 @@
+# AI Pair Programming Walkthrough — Learn by Doing
+
+## Before We Begin
+
+**Diagnostic Question:** What AI coding tools have you used (Cursor, Copilot, ChatGPT, etc.)? For which tasks did they help most — and for which did they fall short?
+
+**Checkpoint:** You have a sense of the AI tools landscape. You're ready to think about when AI helps vs when human judgment is essential.
+
+---
+
+## Step 1: Identify the Right Tool
+
+Not every task is best for AI.
+
+<!-- hint:buttons type="multi" prompt="Which tasks suit AI assistance?" options="Repetitive code,Architecture decisions,Debugging,Documentation" -->
+
+**Task:** For each scenario, decide: AI, Manual, or Both (AI drafts, you refine)?
+
+1. Add a new REST endpoint that mirrors an existing one
+2. Debug a race condition in your WebSocket handling
+3. Write a README for your project
+4. Choose between Redis vs Memcached for your caching layer
+
+**Question:** What made you choose AI vs manual for each? What kind of context does the AI have (or lack) in each case?
+
+**Checkpoint:** The user should recognize that repetitive/structured tasks (1, 3) suit AI; subtle debugging (2) and architecture (4) need human judgment. Both can mean AI drafts, human reviews.
+
+---
+
+## Step 2: Write a Specific Prompt
+
+<!-- hint:list style="cards" -->
+
+Vague prompts lead to generic output.
+
+**Task:** You want to add input validation to a signup form. Your form has `email` and `password` fields. Write a prompt that gives the AI enough context to produce useful code.
+
+Include: (a) what to validate, (b) any existing patterns (e.g., "we use `zod`"), (c) where the form lives (file/component).
+
+**Question:** What would happen if you only said "add validation"? What extra information did you add and why?
+
+**Checkpoint:** The user's prompt includes at least: fields to validate, validation rules (format, length), and where to put the code. They can explain why each piece matters.
+
+---
+
+## Step 3: Provide Examples
+
+Show, don't just tell.
+
+**Task:** Your codebase uses a custom `useApi` hook. Write a 2–3 sentence prompt that shows the pattern so the AI can add a new API call correctly.
+
+Example hook usage: `const { data, loading, error } = useApi('/users', { method: 'GET' });`
+
+**Question:** Why might "use our useApi hook" fail? What does the example give the AI that words alone don't?
+
+**Checkpoint:** The user includes a concrete example of the hook in use. They understand that examples disambiguate style and reduce wrong guesses.
+
+---
+
+## Step 4: Iterate with Narrow Feedback
+
+<!-- hint:card type="tip" title="Narrow feedback" -->
+
+Practice giving feedback that helps the AI correct course.
+
+**Task:** The AI produced a function that uses `var` and a `for` loop. You want `const` and `.map()`. Write the feedback you'd give — without rewriting the whole function yourself.
+
+**Question:** What's the difference between "use modern JS" and "replace the for loop with .map() and use const instead of var"? Which gets better results?
+
+**Checkpoint:** The user's feedback is specific (naming the constructs to change) and doesn't rewrite the code. They understand that narrow feedback is more actionable.
+
+---
+
+## Step 5: Review AI Output
+
+Treat AI output as a draft to verify.
+
+<!-- hint:code language="javascript" highlight="1,4" -->
+
+**Task:** The AI suggested this code:
+
+```javascript
+async function fetchUser(id) {
+  const res = await fetch(`/api/users/${id}`);
+  return res.json();
+}
+```
+
+List at least 3 things you'd check before merging: correctness, safety, edge cases.
+
+**Question:** What could go wrong in production with this code? What would you add or change?
+
+**Checkpoint:** The user identifies: no error handling, no check for non-OK status, possible JSON parse errors, no loading/empty states. They propose at least one concrete fix (e.g., check `res.ok`).
+
+---
+
+## Step 6: Use Skills and MCP
+
+Leverage structured capabilities.
+
+**Task:** Look up what skills or MCP tools are available in your setup (e.g., spec-writer, argus, code search). Pick one and describe a task where invoking it would help.
+
+**Question:** When would you use a skill vs just asking in natural language? What does the skill give you that a freeform prompt doesn't?
+
+**Checkpoint:** The user can name at least one skill or MCP tool and explain when it's useful (e.g., spec-writer after a feature change, argus for testing). They understand skills encode procedures.
+
+---
+
+## Step 7: Decide When to Take Over
+
+Know when AI isn't the right tool.
+
+**Task:** You've asked the AI to fix a bug three times. Each fix either doesn't work or introduces a new bug. What do you do next?
+
+**Question:** At what point does iterating with the AI cost more than debugging yourself? What signals tell you to take over?
+
+**Checkpoint:** The user proposes: gather more context (logs, repro steps), try a narrower prompt, or take over and fix manually. They recognize diminishing returns from repeated AI attempts.

package/modules/ai-test-generation/content.md

@@ -0,0 +1,125 @@
+# AI-Assisted Test Generation — Using Claude for Coverage
+
+<!-- hint:slides topic="AI test generation: AI strengths and weaknesses, prompting for tests, review pitfalls, and human+AI workflow" slides="5" -->
+
+## What AI Is Good At (and Bad At)
+
+**Good at:**
+- Generating boilerplate (describe, it, expect)
+- Suggesting edge cases (empty, null, boundary)
+- Creating test data (fixtures, mocks)
+- Drafting test doubles (stubs, mocks)
+- Writing tests for well-structured, documented code
+
+**Bad at:**
+- Understanding *intent* without context
+- Knowing what *matters* to your business
+- Judging test quality (shallow vs deep assertions)
+- Choosing what to test when time is limited
+
+AI amplifies your judgment. You direct; AI drafts.
+
+## Prompting for Tests
+
+### Provide Context
+
+- **Function under test**: Paste the code.
+- **Framework**: Jest, Vitest, Playwright, etc.
+- **Examples**: One good test as a style reference.
+- **Constraints**: "No mocks for X", "Use testing-library for React".
+
+```javascript
+// Example prompt context:
+// "Here's my function. Generate unit tests with Vitest.
+// I want: happy path, empty input, invalid input, and one edge case.
+// Style: use describe/it, expect().toBe() for primitives."
+```
+
+### Example Prompts
+
+- "Generate unit tests for this function. Include happy path, null/empty, and error cases."
+- "Write 3 integration tests for this API endpoint. Use the existing test setup."
+- "Suggest edge cases I might have missed for this validation function."
+- "Generate a Jest mock for this service. I need to verify it's called with the right arguments."
+
+## Reviewing AI-Generated Tests
+
+### Common Pitfalls
+
+| Pitfall | What to check |
+|---------|----------------|
+| **Shallow assertions** | `expect(result).toBeDefined()` — asserts little |
+| **False confidence** | Tests pass but don't verify real behavior |
+| **Over-mocking** | Mocks everything; integration value lost |
+| **Missing edge cases** | AI often hits obvious cases, misses subtle ones |
+| **Wrong framework** | Jest vs Vitest, RTL vs Enzyme — verify APIs |
+
+### Review Checklist
+
+- [ ] Assertions verify *behavior*, not just "it didn't throw"
+- [ ] Edge cases and error paths are covered
+- [ ] Mocks are justified (isolate unit vs test integration)
+- [ ] Test names describe what is being tested
+- [ ] Tests are independent (no shared mutable state)
+
+## AI Across Test Layers
+
+| Layer | AI Strength | Human Must |
+|-------|-------------|------------|
+| **Unit** | Boilerplate, edge cases | Choose what to test, verify assertions |
+| **Integration** | Setup, fixtures, API contracts | Verify real flows, DB state |
+| **E2E** | Selectors, steps | Scenarios that matter, flakiness |
+
+## Iterating on Generated Tests
+
+1. **Generate** — Get a first draft from AI.
+2. **Run** — Do they pass? Fix setup/import errors.
+3. **Review** — Strengthen weak assertions, add missing cases.
+4. **Refine prompt** — "Add tests for when the API returns 500" or "Use arrayContaining for the response."
+5. **Repeat** — Use feedback to improve future prompts.
+
+## AI for Test Data Generation
+
+AI can generate:
+- Realistic fake data (names, emails, dates)
+- Boundary values (min, max, zero)
+- Invalid inputs for negative tests
+- Complex nested structures
+
+```javascript
+// Prompt: "Generate 5 valid and 3 invalid sample inputs for
+// this email validation function"
+```
+
+## AI for Accessibility Testing
+
+AI can suggest:
+- ARIA attribute checks
+- Keyboard navigation tests
+- Color contrast assertions
+- Screen reader flow tests
+
+Still verify with real assistive tech; AI can miss nuance.
+
+## Workflow: Human + AI
+
+```mermaid
+flowchart LR
+    A[You: function + context] --> B[AI: draft tests]
+    B --> C[You: run + review]
+    C --> D{Good enough?}
+    D -->|No| E[You: refine prompt]
+    E --> B
+    D -->|Yes| F[You: commit]
+```
+
+---
+
+## Key Takeaways
+
+1. **AI drafts, you direct** — Provide context, examples, constraints.
+2. **Review critically** — Shallow assertions and over-mocking are common.
+3. **Use AI for boilerplate and suggestions** — Not for deciding what matters.
+4. **Iterate** — Refine prompts based on output quality.
+5. **Combine layers** — AI for unit draft; human for integration/e2e strategy.
+6. **Test data and accessibility** — AI can help; human verification still essential.