Based on a tutorial by Cole Medin
If you’ve been struggling with inconsistent results from AI coding assistants like Cursor or Windsurf, you’re not alone. We’ve all been there – watching our AI go from acting like a senior developer to completely destroying our codebase in just a few prompts.
I’m summarizing Cole Medin’s comprehensive workflow because he’s cracked the code on getting consistent, high-quality outputs from AI coding tools. This isn’t about building toy projects – we’re talking about a professional-grade process that works regardless of your tech stack or preferred AI IDE.
Quick Navigation
- The 7 Golden Rules for AI Coding (00:00-08:00)
- Planning Phase: Setting Up for Success (08:00-12:00)
- Configuring Global Rules (12:00-15:00)
- MCP Server Configuration (15:00-18:00)
- Initial Implementation Process (18:00-25:00)
- Testing & Git Management (25:00-30:00)
- Iteration & Documentation (30:00-32:00)
- Deployment Strategy (32:00-35:00)
The 7 Golden Rules for AI Coding
Before diving into any code, you need to understand the fundamental principles that make AI coding assistants work consistently. These aren’t suggestions – they’re non-negotiable rules that prevent your AI from going off the rails.
The Core Rules:
- Use higher-level markdown documents: Create planning.md and tasks.md files to provide context
- Keep code files under 500 lines: Longer files confuse the LLM and increase hallucinations
- Start fresh conversations often: Long conversation threads bog down performance
- One feature per prompt: Don’t overwhelm the AI with multiple requests
- Always write tests: Ask for tests after every new feature implementation
- Be extremely specific: Include technologies, libraries, and expected outputs
- Handle environment variables yourself: Never trust AI with API keys or security
My Take:
The environment variable rule is crucial. Cole mentions a developer who built an entire SaaS with Cursor but got hacked two days later because they let AI handle security. Always review and secure your own authentication and database access.
Planning Phase: Setting Up for Success
This is where most developers skip ahead to coding and regret it later. The planning phase sets up your entire project foundation and gives your AI the context it needs to make smart decisions.
Essential Planning Documents:
- planning.md: High-level vision, architecture, constraints, and technology decisions
- tasks.md: Granular task tracking that the AI can update throughout development
- Multi-LLM approach: Use different AI models for planning to get diverse perspectives
Cole recommends creating these files using a chatbot like Claude Desktop rather than jumping straight into your coding IDE. This separation helps you think strategically before getting into implementation details.
My Take:
The multi-LLM planning approach is brilliant. Using platforms like Global GPT (Cole’s sponsor) lets you compare outputs from Claude, GPT-4, and Deepseek simultaneously without multiple subscriptions. The different perspectives often reveal planning gaps you’d miss with a single model.
Configuring Global Rules
Think of global rules as system prompts that apply to every interaction with your AI coding assistant. Instead of typing the same instructions repeatedly, you set them once and they apply automatically.
What Global Rules Should Include:
- Instructions to read planning.md at conversation start
- Automatic task checking and updating in tasks.md
- Testing requirements for all new features
- Code style and documentation standards
- File length limitations and organization rules
Cole provides specific setup instructions for Windsurf, Cursor, Cline, and Bolt. The key is setting workspace-specific rules rather than global ones, since different projects use different technologies.
Example Global Rule Structure:
- Always read planning.md at conversation start
- Reference tasks.md for current project status
- Write comprehensive tests for all new features
- Keep all code files under 500 lines
- Update documentation with each feature
MCP Server Configuration
MCP (Model Context Protocol) servers supercharge your AI IDE by giving it additional tools. Cole considers three servers essential for any serious development workflow.
Essential MCP Servers:
- File System: Access files outside your current project directory
- Brave Search: Web search with AI-powered result summarization
- Git: Version control operations and backup creation
The Git server is particularly crucial because it enables you to create savepoints throughout development. When your AI inevitably breaks something after multiple iterations, you can revert to a known working state instead of starting over.
My Take:
The backup strategy Cole outlines here has saved me countless hours. Making git commits before major feature additions means you’re never more than a few commands away from a working codebase, even when AI goes rogue.
Initial Implementation Process
This is where Cole’s approach really shines. The initial prompt isn’t just “build X” – it’s a carefully crafted request that includes documentation, examples, and specific technical requirements.
Components of a Powerful Initial Prompt:
- Links to relevant documentation (MCP docs, Supabase docs)
- GitHub repository examples of similar implementations
- Specific technology stack requirements
- Expected functionality and output format
In the demo, Cole builds a complete Supabase MCP server – nearly 300 lines of production-ready code – in a single prompt. The AI automatically references the planning documents, follows global rules, and creates a comprehensive implementation.
My Take:
The key insight here is frontloading context. Spending extra credits on documentation search and example analysis in your initial prompt pays dividends throughout the project. It’s like giving your AI a senior developer’s knowledge base from day one.
Testing & Git Management
Once you have a working implementation, the next steps are crucial: create comprehensive tests and establish version control checkpoints.
Testing Best Practices:
- Test successful scenarios, error handling, and edge cases
- Mock external API calls to keep tests fast and free
- Create dedicated test directories with clear organization
- Aim for comprehensive coverage – test files often exceed source code length
Cole’s example generates 14 comprehensive tests covering all scenarios. The AI handles the complex mocking automatically because the global rules specify testing requirements upfront.
# Running the generated tests
pytest tests/
# Result: 14 tests passing, comprehensive coverage
The Git integration allows for strategic checkpoints. After successful implementation and testing, create a commit before moving to the next feature. This creates a safety net for future iterations.
Iteration & Documentation
With your foundation solid, iteration becomes straightforward. The key principle remains: one change per prompt, keeping conversations focused and manageable.
Effective Iteration Strategy:
- Request single features or improvements per conversation
- Keep planning and task documents updated automatically
- Generate documentation (README files) as separate tasks
- Maintain testing coverage with each new feature
The beauty of this system is that your AI maintains context across conversations through the markdown files, while fresh conversations prevent the performance degradation that comes with very long threads.
Deployment Strategy
The final step transforms your local project into a deployable application. AI assistants excel at creating deployment configurations because Docker and similar tools have extensive training data.
Deployment Essentials:
- Docker containerization for consistent environments
- Comprehensive README with installation instructions
- Configuration examples for different platforms
- Build and deployment command documentation
# Example AI-generated Dockerfile structure
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "server.py"]
The end result is a complete, production-ready application that others can clone and deploy following clear documentation – all generated through this systematic AI-assisted workflow.
