AI is incredibly powerful, but it needs guidelines. “Vibe coding” might work initially, but as the project grows, it creates more mistakes than it solves. After fixing countless AI implementations, I’ve distilled it down to three core principles that actually work.

The current wave of AI tools promises to 10x your development speed. What they don’t mention is how they can also 10x your debugging time if implemented poorly. I’m building tools to solve exactly this problem, and I’m sharing some lessons I’ve learned along the way.

1. Structure Your AI’s Context

The “context” is the only thing the AI knows. If it’s incomplete, the AI will make mistakes. To increase accuracy, you need to provide the AI with as much relevant context as possible.

  1. Create a project_milestones.md file that contains an overview of the project and your goals, along with a list of milestones and their descriptions. You may generate this file using chatgpt or claude, or you can create it manually. Then, reference it in your rules. Example:

     Phase 1: Manual Operations & Testing
 - Basic API integration
 - Database schema setup
 - Basic OpenAI integration
 - Manual data collection script
 - Manual analysis trigger
 - Manual review interface
 Phase 2: ...
  2. Maintain a documentation.md file that tracks things relevant to your project from different perspectives. This might include, but not limited to:
    • API endpoints and their request/response formats
    • Database schemas
    • Function specifications
    • Architecture decisions
  3. Set up clear rules in your .cursorrules file to ensure that the AI uses the newly created files: 
      Project Management:
  - Reference @project_milestones.md for all feature implementations
  - Reference @documentation.md for all API endpoints
  - Ensure new code aligns with defined milestones

2. Break Down Complex Tasks

Back-and-forth with the model often leads to compounding errors. Keep tasks focused. When something breaks, don’t spiral into a debugging maze. Instead:

  1. Revert to a previous working state using the checkpoints feature or git.
  2. Break the task into smaller, isolated changes. Test each tiny change independently, only once it’s working, move on to the next change.
  3. If the model starts creating new problems while fixing old ones, stop and reassess. Revert to a previous working state, then start the task again. Do not keep working in a long chat, because as the context grows, the AI becomes more likely to make mistakes.

Become a 10x dev with AI

The world of programming is changing, are you keeping up?

Get my free guides & become 10x more productive with AI.

    I don't spam. Unsubscribe at any time.

    Built with Kit

    3. Use the Right Models

    There are so many AI models, understand the strengths and weaknesses of each and use the right ones at the right time. Adapt your AI workflow based on task types:

    For Planning:

    • Use reasoning-focused models (like 3.7 max mode)
    • Create high-level architecture decisions first
    • Plan feature roadmaps and save it in md files like project_milestones.md

    For Implementation:

    • Use standard models for code generation (my favorite is sonnet 3.5)
    • Ensure each task is well-defined and small
    • Test each change independently
    • Commit to git early and often

    Making It Work In Practice

    Here’s a practical setup that works:

    1. Project Structure: 
      ├── .cursor/
│   ├── rules
├── docs/
│   ├── project_milestones.md
│   └── documentation.md
└── src/
    2. Regular Maintenance:
      • Reindex your codebase regularly in Settings → Cursor settings → Features
      • Update documentation as you complete milestones by tracking architecture decisions and their reasoning
    3. Development Workflow:
      • Start each session by referencing your project context defined in the documentation.md and project_milestones.md files
      • Work in small, testable increments
      • Update milestone progress and documentation consistently, you can even ask the AI to do it for you
      • Document learnings and edge cases
      • Commit to git early and often

    Looking Forward

    The teams who will win with AI are the ones with solid fundamentals. This structured approach might seem annoying at first, but it’s the difference between AI being a productivity multiplier versus a technical liability in the long-term.

    Remember: AI is a powerful tool, but it needs clear boundaries and expectations. By implementing these principles, you’re building a foundation that can reliably scale as AI capabilities grow.

    P.S. My AI improves code generation in production & helps you ship faster. Loved by developers & teams all over the world. Check out Giga AI.