How to use AI for coding: The simple vs. complex framework that unlocks real productivity gains

The engineers getting the biggest gains from AI do one thing differently before they start working: they sort the task in front of them.

What can AI handle mostly on its own? What needs their judgment all the way through?

That distinction shapes everything that follows. It changes how you prompt, how you plan, how many things you can run at once, and where your attention actually belongs.

Start by sorting the work

A useful way to think about AI-assisted coding is to sort engineering tasks into two categories: simple and complex.

Simple tasks are isolated, well-defined, and aimed at a predictable output.

The request is clear enough that AI can often handle most of the work with minimal back-and-forth. The review process is straightforward, and the blast radius is relatively small if something needs to be corrected.

Complex tasks involve ambiguity, dependencies, or decisions that require judgment at multiple points.

These benefit from a human in the loop throughout. The planning matters just as much as the execution, and the quality of the outcome depends heavily on the quality of the structure you set up at the start.

Once you begin working this way, it becomes much easier to build a workflow that actually fits the task.

Parallelize the simple, focus on the complex

From there, a practical workflow follows:

• Run several simple tasks at the same time.
• Give one complex task your full attention.

Simple tasks are often good candidates for parallel work. If they are well scoped and unlikely to interfere with one another, you can queue them up in the same codebase and review the outputs later in a batch.

This works especially well around natural pauses in the day, like before a meeting, before lunch, or before switching contexts. Instead of treating AI like something you need to supervise moment by moment, you can treat it more like an async collaborator that can move work forward while your attention is elsewhere.

Complex work benefits from a different rhythm. It usually requires active decisions as the work unfolds. The plan may need to adapt. Tradeoffs may surface halfway through. In those cases, giving one complex task your full attention usually leads to better results than trying to split your focus across several at once.

Planning is where a lot of the leverage lives

With AI, the planning step becomes even more valuable.

Before writing a prompt for a complex task, it helps to get clear on a few things:

• What you’re building and why
• Where the boundaries sit between systems
• What data is moving where
• What assumptions each component depends on
• Where the structure might break under pressure

AI tends to work best when the task is well framed. A clear plan creates better prompts, cleaner execution, and less rework later. It also gives you a stronger lens for reviewing what comes back.

Evaluate the plan before you scale the execution

A big part of using AI well is knowing when a plan is ready.

That usually means reading the plan critically, checking for missing assumptions, and making sure the boundaries between pieces are actually clear. If something feels off, it often helps to run the plan through a second model and ask for critique. A fresh pass can surface gaps, conflicts, or weak reasoning that are easy to miss on the first round.

It also helps to respond with specific feedback. Precise objections tend to sharpen the next iteration much more effectively than general dissatisfaction. The goal is to refine until the plan clears your bar for clarity and soundness, then move into execution.

That judgment step matters. In an AI-assisted environment, one of the most valuable skills is knowing when the thinking is strong enough to move forward.

Let execution run, then review with intention

Once the plan is strong, execution often goes better when you let it breathe.

Modern agentic tools can break work into steps, revise earlier decisions, and move through a structured task with a fair amount of independence when the inputs are strong. That makes it possible to step back a bit and use your attention elsewhere while the work runs.

A useful rhythm looks like this:

• Queue work before natural breaks
• Use those gaps to run simple tasks in parallel
• Think through the next stage of a complex task while execution is happening
• Review outputs in batches instead of interrupting the flow every few minutes

This creates a workflow in which your attention is spent where it adds the most value, rather than being pulled into constant low-level supervision.

How to apply this framework

At the beginning of a work session, try this:

• List the tasks in front of you
• Sort each one into simple or complex
• Batch the simple tasks that can run in parallel
• Choose one complex task to focus on
• Do the planning work on that complex task before opening any AI tool

This approach helps create a more deliberate workflow. You start matching the shape of the work to the right level of AI involvement, instead of treating every task the same way.

That is often where the biggest productivity gains begin.

Put this into practice with a Formation Studio session

Reading about a better workflow is useful. Actually changing how you work usually takes something more interactive.

Formation Studio sessions are live workshops where engineers can pressure-test ideas, ask questions, and work through frameworks like this with an expert in the room. Instead of trying to apply a new workflow in isolation, you get to talk through where it breaks down, where judgment still matters most, and how to adapt it to the kind of work you actually do. 

If this framework changed how you think about using AI for coding, a Studio session is a strong next step. Find one here.