Sitemap

Vibe Engineering?

4 min readSep 1, 2026

--

Press enter or click to view image in full size

What would I do if all I had was my favorite coding agent CLI — Claude Code, Codex, or GitHub Copilot?

No custom agents, no custom skills, no MCP, no fancy tools, and not even a multi-agent framework.

After using such a setup for the last few days, here is my simple and pragmatic workflow.

The Essence

The basic idea is simple:

  1. Define a goal and make a plan
  2. Break the plan down into small slices
  3. Incrementally implement and verify each slice until the goal is achieved

When working with coding agents, there is one additional rule I consider important:

Planning, implementation, and verification should happen in separate sessions.

The Workflow

Press enter or click to view image in full size

1. Create the plan

Open your coding agent CLI and describe what you want to achieve. Give it the goal, acceptance criteria, and relevant constraints. Then ask it to create an implementation plan and break the work down into slices that can be implemented and submitted individually.

2. Review the plan

Review the proposed plan, including the slicing. If you are not happy with it, iterate with the planner until you are. Once the plan looks good, close the session.

3. Implement the first slice

Open a new coding agent session and ask it to implement the first slice. Let it make the changes and verify the implementation. Once it is done, keep the session open.

4. Review the implementation

Open a second session and ask it to review the pending changes. The reviewer should check whether the implementation matches the plan and whether it introduced any bugs or design issues. Tell the reviewer to write its findings into files.

If there are any review findings, switch back to the implementation session and ask it to fix them. Once the findings are fixed, ask the reviewer to review the changes again.

Get Plainionist’s stories in your inbox

Join Medium for free to get updates from this writer.

Repeat this until the slice is completed without any further review findings.

5. Continue with the next slice

Repeat implementation and review for every remaining slice until the complete plan is implemented. Then close all open sessions.

That is the whole workflow.

Tips & Tricks

For planning and review, use a high-end model like Sol with high or even max reasoning effort.

For implementation, a medium model like Terra with medium effort seems to be sufficient for most tasks.

Keep your prompts generic. That way, you can simply use cursor-up and run the same prompt again instead of continuously writing new instructions.

Here are a few examples:

Review the pending changes. Do they fulfill the task? Any bugs introduced? Do not run any tests — just do a code and design review. Only report real issues — no cosmetics. Create one issue for every finding with priority 1 and prefix `review` under `docs/issues/`, if any.

After the implementer has fixed the findings:

Findings fixed — re-review.

And in the implementation session:

New review findings — pull all priority 1 issues prefixed with `review`.

Surprisingly Little Setup

I have used this workflow for the last few days to develop some non-trivial features, and it worked surprisingly well with almost no setup.

I did not specify any roles explicitly. There are no special agent files describing a Planner, Implementer, or Reviewer. I only have some very basic repository instructions, such as my preferred naming conventions and general principles like KISS and separation of concerns.

Even with that minimal setup, the reviewer regularly found real issues. For some non-trivial slices, it took three or more implementation-review cycles until no findings were left.

And I did not carefully review all tests myself or establish architecture fitness functions or other deterministic quality gates. I mostly left that to the agents.

Still, the results were remarkably good.

The Drawback

There is one downside to this approach: Micromanagement.

You have to start the sessions, tell the next agent what to do, switch back to the implementer when there are findings, trigger another review, start the next slice, and so on.

At some point, you cannot avoid the feeling that you are working for the agents instead of the agents working for you. 😉

And that is exactly why, in the long run, you probably want some kind of multi-agent orchestration. 😉

--

--