AI Agent Workflow: Break an Idea into Issues with Completion Criteria

Your notes app keeps filling up with ideas, but only a few of them ever get built. This post walks through an AI agent workflow that breaks a single idea note into issues an agent can actually finish, then hands them off one at a time and verifies each one. It includes an example idea note, a prompt for splitting it, and what a finished issue looks like, all ready to copy.

I used to design this as an org chart, with a planning agent and developer agents in separate roles, plus a pipeline that watched a folder. That design never actually worked. I explained why in 4 Real AI Agent Automation Examples: Hand Off Goals, Not Chats. This post is the approach I switched to afterward.

Think in Four Steps, Not an Org Chart#

What matters more than giving agents job titles is which documents the work passes through on its way to done. Four steps are enough.

Your job is deciding what to build and why, and confirming when it's done. The agent handles the first draft of the split and the implementation. Memory lives in notes, issues, and git, not in a chat.

Step 1: Write the "Why" and the "Won't Do" in Your Idea Note#

An idea note can be short, but it needs three things. Say you want to add social login to your app. You'd write this.

# Add Social Login
 
## What I want
 
Add Kakao and Apple login to the app.
 
## Why
 
I want users to be able to sign up more easily.
 
## Won't do
 
- This time, don't merge existing email accounts with social accounts
- Google login comes later

Kakao is the dominant messaging app in Korea, so think of it as the local equivalent of "Sign in with Google."

1. What I want — one or two sentences on what to build.
2. Why — this becomes the agent's tiebreaker when something is ambiguous. Without it, the agent guesses whatever seems most plausible.
3. Won't do — this cuts the scope. Agents often helpfully do things you never asked for.

You don't need to write how to build it. You'll work that out with the agent in the next step.

Step 2: Split the Idea into Issues by Chatting with an AI Agent#

Splitting works better as a conversation than as an automated job. Deciding how to break up an idea takes a lot of judgment, so it's faster to let the agent draft and fix the draft right away. Even in continuously running automation loops, the spec is often written through conversation first.

Give a coding agent like Claude Code or Codex the idea note along with a prompt like this.

Split the attached idea note into draft issues.
 
- Size each issue so it can be finished in a single PR.
- For each issue, write the goal, context, completion criteria, verification, and don'ts.
- Write completion criteria as sentences you can check as pass or fail.
- If you can't write completion criteria, split it further.
- Put a link to the original idea note in the context.
- Don't create the issues yet. Just show me the drafts.

The last line matters. Reading and fixing the drafts is the cheapest point for a human to step in. Filter out vague issues here, and you'll spend far less time wrestling with the output later.

What an Issue with Completion Criteria Looks Like#

The idea above would split into a UI issue and a server issue. The UI issue looks like this.

# Implement Kakao Login UI
 
## Goal
 
Let users start a Kakao login from the login screen.
 
## Context
 
- Idea note: ideas/social-login.md
- Server integration is handled in a separate issue
 
## Completion criteria
 
- The login screen shows a Kakao login button
- Tapping the button moves to the Kakao auth screen
 
## Verification
 
- Add a login screen test and make it pass
- Attach a screenshot of the running screen to the PR
 
## Don'ts
 
- Don't change the layout of the existing email login screen

This issue structure is the goal, context, completion criteria, and don'ts layout from Using Obsidian Notes as Work Orders for AI Agents, with verification added. Keeping a link to the idea note in the context lets you trace any issue back to the idea it came from, no matter how many issues it was split into.

Check Before You Hand It Off#

• Are the completion criteria checkable sentences?
• Can it be finished in a single PR?
• Is there nothing left you'll need to add after handing it off?

The third one matters more than it looks. GitHub's official docs say Copilot can't see comments added to an issue after it's been assigned. Whatever you want to say, write it all in the issue body before you hand it off.

Step 3: Hand Issues to the Agent One at a Time#

Once the issues are ready, run them on tools you already use. There's no need to build a new folder watcher or assignment engine.

• GitHub issues — assign Copilot under Assignees, or mention @claude in an issue comment, and the agent creates a branch, does the work, and returns a PR.
• Issue-tracker-style tools — in a tool like Multica, you assign the issue to an agent and run it.
• Directly on your machine — give your coding agent the issue body as-is and run it.

Whichever you pick, the rule is the same: hand off one issue at a time. Ask for too much at once, and the agent tends to run out of context partway through and stop with things half-built.

If you want to run several issues at once on your own machine, use a Git worktree. A worktree is a Git feature that checks out the same repository into a separate folder per branch. Each agent gets its own folder, so they don't overwrite each other's files.

Step 4: Judge "Done" by Verification, Not by the Agent's Word#

Even when the agent says "all done," don't take it at face value. The verification you wrote in the issue is the standard.

1. Automated checks — tests, static analysis, and type checks reject bad results first. Hook them into CI and they run on every PR.
2. Human review — in the PR, check each completion criterion, look at the screenshots or run results, then merge.
3. When the same mistake repeats, fix the instruction file — add a line to a rules file like CLAUDE.md in your repo, and the agent makes that mistake less often from the next issue on.

Once every issue is merged, mark the idea note "done" and add the PR links. That way a single idea note becomes a record of what you built, why, and where to check it.

Add Automation Later, and Only for Repeating Work#

It's tempting to build a pipeline from day one where you drop in an idea and everything runs on its own. But maintaining the automation itself costs more than you'd expect. Start small, in this order.

1. Write one idea note in the format above.
2. Chat with an agent to get draft issues, then read and fix them yourself.
3. Hand one issue to the agent, check it against the verification steps, and merge.
4. Only when the same kind of work keeps repeating, automate it with scheduled runs or a feature like Multica Autopilots.

Finishing an Idea Isn't About How Much You Automate#

What turned ideas into real output wasn't an elaborate org of agents. It was issues with written completion criteria and the habit of judging "done" by verification. With those two, even solo and with a single agent, your ideas make it all the way to code.

Start today by writing down one idea that's been living in your head and asking an agent for draft issues.

He who has imagination without learning has wings but no feet.

— Joseph Joubert