AUGMENT
ch_6

Ch 6: Putting It Together

Chapter 6

The 10 rules and your first week action plan.

Chapter 6: Putting It All Together

You've learned the mental models, the context engineering framework, and the tools. Now let's tie it all together with practical rules and your first week action plan.

The 10 Rules for Productive AI-Assisted Development

These rules apply whether you're vibe coding a side project or augmented engineering in production.

//Rule 1: Use a Tool That Has an Agent

To get the biggest productivity gains, have an agent write as much of your code as possible.

If you've only used Copilot, you'll be surprised how hands-off you can actually be. Tools like Cursor and Claude Code can build entire features without you typing code.

Action: Use Cursor with Agent mode enabled, not just autocomplete.

//Rule 2: Start New Chats for Each Discrete Task

State-of-the-art models have massive context windows, but just because you CAN stuff tons of history in doesn't mean you SHOULD.

Irrelevant tokens (chat history from a different task) increases the likelihood of worse responses.

Action: Open a new chat session for each distinct task. One bug fix = one chat. One feature = one chat.

//Rule 3: Use Templates to Your Advantage

Don't start every project from scratch. Find good starter templates for your tech stack and reuse them.

Action: Build or find a template for your common project type. Every new idea shouldn't start with the same boilerplate.

//Rule 4: Make Your Tool Write Tests

AI models like Claude can make more changes than you intend. Tests help you know if changes cause regressions.

The best part? With AI, writing tests isn't tedious anymore.

Action: After implementing a feature, ask the AI to write tests. Then instruct it to run the tests and self-iterate until they pass.

//Rule 5: Commit Often

This isn't unique to AI-assisted development, but it's extra important.

Knowing you can easily move backward lets you approve changes you're not sure about and revisit later.

Action: Commit after every working change. Use AI to generate commit messages if you hate writing them.

//Rule 6: Use Branching So You Can Abandon Work Easily

Start a new branch for each feature, even on side projects. This gives you confidence to let the agent make sweeping changes because you can toss the entire branch if unhappy.

Action: git checkout -b feature/name before starting any substantial work.

//Rule 7: Keep Your Secrets Secure

Never hard-code secrets. Ever.

Keep API keys in environment variables or dotfiles so they:

  • Don't end up in version control
  • Don't get sent to AI model APIs

Action: Use .env files and add them to .gitignore. Never paste secrets into AI chats.

//Rule 8: Don't Put Secrets in Frontend Code

If users shouldn't see it, don't let it end up in client-side code. AI tools can accidentally expose things if you're not careful.

Action: Always verify that sensitive data stays on the backend.

//Rule 9: Deploy Early and Often

Just like you commit often, deploy often. This helps you quickly identify infrastructure problems without digging through thousands of changes.

Action: Get to a deployed state as early as possible, then deploy incrementally.

//Rule 10: Don't Debug on Your Own

In the spirit of AI-assisted development, don't debug without AI assistance. If you're stuck, talk through the issue with your agent.

Better yet, let the agent run commands itself so it can debug without you copy-pasting everything.

Action: When something breaks, immediately share the error with your AI tool. Include the error message, relevant code, and what you expected to happen.

Your First Week Action Plan

Here's how to get productive with AI tools in your first week:

//Day 1-2: Setup

Hour 1: Install and configure

  • Install Cursor
  • Set up global rules (copy from Appendix B)
  • Configure auto-run settings with safety guardrails

Hour 2: First project setup

  • Open an existing project in Cursor
  • Create .cursor/rules/ directory
  • Add project-specific rules for your tech stack

Hour 3: Try it out

  • Pick a small, low-risk task
  • Use Agent mode to complete it
  • Practice @ references for context

//Day 3-4: Build Your Workflow

Practice these patterns:

  • Start a feature with clear intent: "Create a component that..."
  • Debug with context: "I'm getting this error... [paste error]"
  • Refactor safely: "Refactor this function to..."
  • Write tests: "Write tests for this function that cover..."

Key habit to build: Start every new task with a fresh chat.

//Day 5-7: Build Something Real

Pick a real project:

  • A feature for work (low-risk first)
  • A side project you've been putting off
  • A tool that solves a problem you have

Apply what you've learned:

  • Use the right approach (vibe coding vs augmented engineering)
  • Practice context engineering
  • Follow the 10 rules
  • Note what works and what doesn't

Troubleshooting Common Early Issues

//"The AI keeps getting things wrong"

Likely cause: Not enough context or unclear intent.

Fix: Use @ references to include relevant files. Be specific about what you want. If it's still wrong, the problem might be ambiguous requirements - clarify them first.

//"The AI made changes I didn't want"

Likely cause: Overly broad instructions or not reviewing changes.

Fix: Be more specific in your prompts. Always review diffs before accepting. Use version control so you can revert.

//"The AI seems stuck in a loop"

Likely cause: The task might be too complex or context is confused.

Fix: Start a fresh chat. Break the task into smaller steps. Give clearer success criteria.

//"I'm not sure when to trust the AI"

Likely cause: This is normal! You're developing calibration.

Fix: Start with low-risk tasks. Always review generated code. Run tests. Over time, you'll learn which tasks the AI handles well.

What's Next?

You now have everything you need to be productive with AI coding tools:

  1. The mental model - Vibe coding vs augmented engineering
  2. The core skill - Context engineering
  3. The tools - Cursor, Claude Code, ChatGPT
  4. The rules - 10 principles for productive AI-assisted development

The only way to get better is to use them.

Start with low-risk work. Build confidence. Gradually increase the stakes.

Within a few weeks, you'll wonder how you ever coded without AI assistance.

Keep Learning

For more guides, updates, and deep dives:

AI tools are evolving fast. What works today will be even better tomorrow. Stay current, stay curious, and keep shipping.

Good luck. Now go build something.