The Junior Developer Model: A 3-Step Workflow for Smarter AI Code Generation

After months of using models to generate code, we realized we were spending more time fixing AI-generated code than writing it ourselves. The solution? A structured three-step workflow that treats AI models like junior developers-with proper context and clear instructions.

Our Journey

We use Visual Studio Code for our development environment, and naturally, we got access to GitHub Copilot and started using it for our development.

Initially, we were using it for generating code and then manually editing it to fit our needs. However, we found ourselves constantly switching between different models based on the use case to get the best results-a workflow that was both time-consuming and inefficient.

Later, we decided to explore other AI coding assistants to see how they compared. We tried Google Cloud CLI, Claude Code, and Cursor. Each tool had its strengths, but Cursor stood out for its structured approach to AI-assisted development.

What made the difference? Cursor's mode-based workflow allowed us to guide the AI through a systematic process, resulting in code that was faster to generate and more accurate from the start.

Our Three-Step Workflow

The key to our success with Cursor lies in using its modes strategically, not just jumping straight to code generation. Here's our systematic approach:

Once we collect requirements from the team, we ensure we fully understand them before involving the AI. Then we follow this three-step process:

1. Ask Mode: Understanding and Planning

In ask mode, we have a conversation with the model. We present our requirements and ask it to analyze the existing codebase to understand how we can implement the solution. This collaborative discussion helps us:

- Identify edge cases and potential failure scenarios

- Design test cases before writing the implementation

- Explore different approaches and their trade-offs

- Ensure the solution aligns with our codebase patterns and conventions

This phase is crucial-it's like briefing a junior developer on the problem before they start coding.

2. Plan Mode: Creating the Roadmap

Once we're confident we've covered all possible scenarios, we move to plan mode. Here, the model takes our agreed-upon solution and:

- Produces comprehensive context about the changes needed

- Identifies all files that will be affected

- Creates a detailed, step-by-step plan to track progress

- Ensures we have visibility into what will change before execution

This planning phase prevents surprises and gives us a clear roadmap, just like a technical design document would for a human developer.

3. Agent Mode: Execution

With a solid plan in place, we enter agent mode. The model now has all the context it needs to execute the changes systematically. Because we've done the upfront work in ask and plan modes, the generated code is:

- More aligned with our requirements

- Better integrated with existing code patterns

- Less likely to require major revisions

- Easier to review and approve

Why This Approach Works

Before adopting this structured workflow, we were essentially always operating in agent mode. The model would try to solve problems with minimal context, often generating code that required significant manual editing. We found ourselves spending more time fixing AI-generated code than we would have spent writing it ourselves.

The constant cycle of generating, reviewing, rejecting, and regenerating code was frustrating and inefficient. We weren't leveraging the full potential of AI assistance.

The Junior Developer Analogy

Here's the insight that changed everything: we treat AI models like junior developers. 

Just as you wouldn't hand a junior developer a vague requirement and expect perfect code, you can't expect AI models to produce quality output without proper guidance. The key is providing:

- Clear context about the problem and existing codebase

- Structured breakdown of complex problems into manageable chunks

- Iterative feedback through discussion and planning phases

- Clear expectations about code quality and patterns

By following this approach, we've transformed our AI-assisted development from a frustrating back-and-forth into a productive collaboration. The models now produce code that's closer to production-ready on the first pass, saving us time and reducing cognitive load.

Key Takeaways

1. Structure matters: Don't jump straight to code generation. Invest time in understanding and planning first.

2. Context is king: Provide comprehensive context about your codebase, patterns, and requirements.

3. Think like a mentor: Guide AI models through the same process you'd use with junior developers.

4. Iterate thoughtfully: Use ask and plan modes to refine your approach before execution.

What's Your Experience?

A quick note on subscriptions: I'd seriously hold off on the annual subscriptions. The AI world is moving so fast-it's like a decade of development every month! Getting that yearly plan was a mistake, and Antigravity is the main reason I wanted to share this quick heads-up.