#010: THE AI PRODUCTIVITY SECRET: HOW TOP DEVELOPERS ARE 10X'ING THEIR OUTPUT WITH THE "PLAN-EDIT-EXECUTE" METHOD

Ready to discover how elite software teams are secretly crushing development cycles with AI? This isn't just another productivity hack – it's a complete transformation in how software gets built.

The $15 TRILLION Dollar AI Revolution No One Is Talking About (Yet)

Picture this: Your team just shipped in two weeks what would normally take two months. Your code quality is up, bugs are down, and your developers are actually enjoying the process.

This isn't fantasy. It's happening right now in the most innovative companies, and it's driven by 100 million people working in the AI space right now and projected to add $15.7 TRILLION to the global economy by 2030.

But here's the truth most R&D managers don't understand: Simply giving your team AI coding tools isn't enough.

A recent Docker AI Trends Report surveying 885 developers found that while AI adoption is skyrocketing—with 64% of developers already using AI for work—many teams may not be maximizing its potential. The survey revealed that developers use AI primarily for tasks like coding (33%), writing documentation (29%), and research (28%).

The Challenge of Effectively Implementing AI in Development Teams

Most teams face a significant challenge when implementing AI into their workflows. They are not using the full spectrum of functionality that AI coding agents offer.

They're treating AI like a magic code generator instead of a strategic development partner.

This approach can lead to problems. It may create technical debt, introduce security vulnerabilities, and ultimately lead to MORE work, not less.

The top 5% of development teams that are seeing extraordinary results are doing something dramatically different. They're using what I call the "Plan-Edit-Execute" methodology.

This transformative approach can boost developer productivity significantly. GitHub's research has found that their AI pair programmer helps developers code up to 55% faster, while their study with Accenture showed an 8.69% increase in pull requests and a 15% increase in pull request merge rates.

It gets better than that. GitHub Co-Pilot was just the beginning. Today we have tools like Cursor and Claude that make for an even better developer experience!

The Plan-Edit-Execute Methodology: Your Unfair Advantage

The heart of this approach is a three-step system that transforms AI from a simple code generator into a true development partner. The key is to integrate AI into the same framework that you would normally follow, optimizing each step along the way with AI and reviewing results the AI produces each step of the way to help align them with what you are trying to do.

PHASE 1: PLAN - The Foundation of AI Workflow

The biggest mistake developers make is jumping straight to code generation. This is not correct. You have to start with planning:

1. Request a detailed implementation plan: Have your AI assistant analyze your codebase and describe exactly how it would implement a new feature before asking it to write a single line of code. The model will use tools to gather context first and then generate a plan.

2. Review architecture decisions: Scrutinize the AI's plan against your existing architecture. Look for misalignments or unnecessary steps. This is where you get to decide exactly what the consequent steps will be.

3. Execute only when happy with the plan: The refined plan becomes your roadmap for implementation, giving you complete control over the process. It becomes your instruction to the model when it's time to do the implementation.

The plan-first approach has shown substantially more effective AI based implementation than any other approach.

Here's an actual example prompt that shows how this works:

Analyze this repository and this @prd.md (product requirements document) and develop a comprehensive plan for implementing all features mentioned in the PRD. Do not implement any code, just write a plan first and save it into planning/plan.md.

PHASE 2: EDIT - The Critical Step 90% of People Don't Even Realize Exists

Once your AI assistant provides a plan, you review and edit it.

1. Evaluate architectural alignment: Assess whether the proposed approach truly fits your project. AI plans often include unnecessary steps.

2. Identify gaps and weaknesses: Spot missing steps that the AI may have overlooked due to its limited contextual understanding.

3. Apply domain expertise: Enhance the plan with your specialized knowledge of the business domain and technical constraints.

Remember, you are like a coin with a muscle. You can direct the AI generation process exactly how you want it using your own ideas and by putting them into the plan. You can accelerate your results and make AI produce exactly what you want.

During this phase, ask yourself:

• "If I had written this plan, would it make sense to implement?"

• "What clarifications would another developer need to implement this correctly?"

• "How can I optimize this plan for long-term maintainability?"

• "Is this how I would explain what needs to be done to an engineer?"

PHASE 3: EXECUTE - Where the Generation Happens

With a solid plan in place, you have enough information for the model to generate exactly what is needed.

1. Incremental implementation: Have the AI implement the full solution, then refine iteratively.

2. Review and enhance tests: The AI will generate tests, but you should always have domain expertise necessary to review them and add edge cases that only experts would know to check.

3. Iterative refinement: Provide feedback on the implementation and have the AI make necessary adjustments, creating a tight feedback loop that produces exceptional code quality. As a domain expert, YOU have the opportunity to really increase your productivity by using your domain expertise to feed AI with correct information to make refinements.

Stack Overflow's blog post on pair programming with AI advocates for treating AI as a pair programming partner, suggesting this approach can be more productive than using AI as just a code generator. As they put it, "It's the AI's job to be fast, but it's your job to be good."

ADVANCED TECHNIQUES: Pushing the Boundaries

The Plan-Edit-Execute methodology is just the beginning. Here are three advanced techniques that top teams are using to extract even more value:

1. Bi-Directional Documentation Synchronization

Keep your code and documentation perfectly aligned:

• Generate documentation from code changes: Have the AI analyze your merge requests and update documentation automatically.

• Implement code based on documentation updates: Make changes to documentation first, then let AI update the implementation to match.

2. Test-Driven Development Supercharged

TDD becomes exponentially more powerful with AI:

• AI-generated test coverage: Have AI generate comprehensive test suites that would take days to write manually.

• Implementation against tests: Write tests first (or have AI generate them), then have AI implement code that passes those tests.

• Automated test expansion: Use AI to identify and fill gaps in test coverage, dramatically improving software reliability.

WARNING: The Common Pitfalls That Will Sabotage Your AI Implementation

Despite the enormous potential, there are dangerous traps that can completely derail your AI implementation:

Pitfall #1: Overreliance on Generated Code

Blindly accepting AI-generated code introduces bugs, security vulnerabilities, and technical debt. The solution is simple but non-negotiable:

• Review generated code with the same rigor as human-written code

• Understand what the code does before integrating it

• Run comprehensive tests on AI-generated code

• Use AI as a collaborator, not a replacement for expertise

Pitfall #2: Neglecting Context and Constraints

AI lacks complete understanding of your project constraints and architectural decisions unless explicitly provided. To overcome this:

• Provide comprehensive context with every request

• Explicitly state constraints and requirements

• Reference existing patterns in your prompts

• Iteratively refine outputs to align with project needs

Pitfall #3: Inefficient Prompting

According to JetBrains' State of Developer Ecosystem 2024 report, the difference between average and elite AI utilization comes down to prompt engineering. Great engineers create prompts that:

• Are clearly structured with specific instructions to the model

• Break complex tasks into focused sub-tasks and implement them in steps

• Include examples of desired outputs so that AI model can generate correct output format

• Evolve based on previous results by executing them - for example by writing a test and executing generated code and then having AI make refinements based on direct feedback from these tests.

The Transformation Starts Now: Your Action Plan

The AI revolution in software development isn't coming—it's already here. The teams that master AI integration now will dominate their industries for the next decade.

Here's your 3-step action plan to implement the Plan-Edit-Execute methodology in your team:

1. Start Small: Choose a non-critical features to implement using AI

2. Train Your Team: Get your team using Cursor and Claude models effectively.

3. Measure Results: Track feature implementation velocity and quality.

The most successful software teams of the next decade won't be those with the biggest budgets or the most developers—they'll be the ones who master the art of human-AI collaboration.

Will your team be among them?

---

P.S. Got questions about getting your team up to speed with AI? Drop me an email to martin.schroder@swedishembedded.com.