Developers everywhere are adopting AI developer tools—from plain ChatGPT to GitHub Copilot, Cursor, Windsurf, and beyond. But taking these tools into use is just the first step; they are not magic wands that let you sit back and relax. Much like a new coworker, you need to figure out how they fit into your workflows and what needs to change now that there are two of you working on the same problem.

Another fitting metaphor for using AI developer tools without the right approach is sending an excavator to a construction site with no plan, fuel, or operator. The tool may be there, but you are far from unlocking its real value. Similarly, simply asking ChatGPT—or even a dedicated AI dev tool—to “fix this code” barely scratches the surface of its capabilities.

Understanding AI Models

The first thing to understand is that modern AI models (LLMs) are probability machines. Their primary function is to predict the most probable next word (or token). If the resulting output isn’t what you expected, it doesn’t mean the model doesn’t “know” the answer you were looking for. Instead, it means that based on its training and your prompt, it predicted the most likely response—which might not align with your expectations.

Why is this important? Because achieving high-quality results is all about optimization. The better the prompt, the better the results. For example, adding just one example of the exact result you expect to your prompt (moving from “zero-shot” to “one-shot”) can increase accuracy by a whopping 50%.

Understanding AI Developer Tools

AI developer tools like Cursor act as middlemen between your code and the AI model. They automate the process of prompting the AI and applying its outputs. To improve results, these tools often incorporate built-in prompt engineering tricks. However, this process is largely a “black box,” limiting your ability to manually optimize the results.

But here’s the good news: context manipulation allows you to influence the tool’s output despite these limitations.

What is Context Manipulation?

One of the key techniques AI tools use is gathering relevant context about your code and task, such as open files, which the tool considers related to your current work. This context is then included in every request sent to the AI model.

Now, consider this simple example: since you know the tool adds open files to the context, what happens if you prompt it to generate code in an empty file under two scenarios:

No other files are open.
Another file with relevant, example code is open.

Even though you don’t have direct access to the tool’s internal prompt, you can influence it by adjusting the tool’s state as in scenario 2. By opening a file with the type of code you expect, you effectively move from “zero-shot” (no examples) to “one-shot” (one example), dramatically improving the quality of results. Conversely, if conflicting files with mismatched styles, languages, or frameworks are open, this will confuse the model and lead to lower-quality outputs.

AI-Optimized Workflow

As we discussed, output quality is a probability optimization problem that can be solved through prompt engineering and context manipulation. Just like working with a new coworker, switching to AI developer tools requires rethinking your workflows to achieve this.

To get the best out of it you need to rethink your whole workflow around context manipulation techniques, such as:

Keeping only relevant files open.
Using version control effectively.
Iterating with clear, focused scopes.
Code and file structure.
Comments and commenting style.
Codebase and documentation indexing.
Prompt engineering of the task.
File references.
Using features for what they are meant for.
Static instructions and optimizing them for the current workflow.
Breaking tasks into parts that afford better optimization based on all the other techniques.
And many more.

For example, when creating new features with Cursor, start with high-level planning in Chat, generate scaffolding code with Composer, and refine outputs through smaller, targeted prompts with inline prompting and Tab.

Does It All Matter?

I train teams on these principles through my 10x Developer Training, and the proof is in the pudding. Participants report that learning context manipulation and optimizing workflows leads to significant jumps in productivity and happiness. While the exact gains depend on the task, most report up to 5–10x increases in productivity, even when the same tools are already in use. One lead, for instance, reported completing tasks estimated to take days in a few hours.

Here’s a simple example:

Code generation: Without vs. With AI-Optimized Workflow

On the left is the result of a generic prompt, producing unspecific and disappointing output. On the right, the same exact tool and prompt are used, but with an AI-optimized workflow it yields essentially production-ready code.

The Bottom Line: Garbage In, Garbage Out

The bottom line is that you need to treat the code generation as a probability optimization problem, with each optimization technique increasing the accuracy of the results. In the center of this is the context you provide—through workflows and habits—determines whether you see exceptional results or fall short. Engineering the prompts through context manipulation is the key to significant productivity gains from AI tools.

If your results aren’t meeting your expectations, it’s probably not the tool—it’s how you’re using it. Remember: garbage in, garbage out.

Why Your AI Dev Tool Results Suck—and How to Fix Them