GenAI-based development platform - part 2: How Idea to Code turns an idea into working, tested software

This article is the second in a series about the GenAI-based development platform (aka. harness) that I’ve been developing to make GenAI-based coding agents like Claude Code more productive and less frustrating. The platform is a set of tools, constraints and feedback loops that guide their behavior, catch mistakes and prevent them from generating large amounts of poor-quality code that is often incomplete and untested.

The complete list of articles in the series is as follows:

• Part 1 - Guardrails for GenAI coding agents
• Part 2 - How Idea to Code turns an idea into working, tested software

This article is about the last step in the Idea to Code workflow that turns a plan derived from the initial idea into a pull request consisting of production code and tests. The actual development is performed by the i2code implement subcommand.

$ i2code implement docs/ideas/amazing-idea
...
PR marked ready for review
PR: https://github.com/humansintheloop-dev/humansintheloop-dev-workflow-and-tools/pull/31

docs/ideas/amazing-idea is a directory that contains the idea along with a specification and implementation plan that were derived from the idea.

Let’s explore the implementation of this coding agent orchestrator.

How i2code implement orchestrates Claude Code to implement a plan

The i2code implement command combines deterministic Python code and Claude Code invocations.

The following diagram shows how i2code implement works:

The input to i2code implement is a plan derived from the idea and consists of a series of small tasks. The output is a GitHub pull request consisting of roughly one commit per task. The i2code implement command uses TDD, so each commit contains both production code and tests.

Let’s look at how this works in more detail.

Setup phase

The first phase is a one-time setup that, among other things, creates a Git working tree for the branch that will be used to implement the plan. Subsequent runs of i2code implement for the same plan will reuse the same working tree, so the setup phase is only needed once per branch. This step is entirely deterministic, implemented in Python.

Recovery phase

The second phase is the recovery phase, which attempts to recover incomplete work from previous runs of i2code implement for the same plan. If there are uncommitted changes that complete a task, i2code implement invokes Claude Code to generate a commit message and commit the changes. Next, if there are commits in the local repository that haven’t been pushed to the remote, i2code implement pushes them. It then enters the main implementation loop.

Main implementation loop

The implement loop iteratively executes the tasks in the plan until all tasks are completed.

The loop consists of the following steps:

1. Fix any failed GitHub actions workflow for the current HEAD, waiting for the build to complete if necessary. If the build is broken, i2code implement invokes Claude Code to diagnose the failure, and commit a fix. It then pushes the fix and waits for the build to complete again.

2. Respond to comments and reviews of the pull request. If there are any comments or reviews requesting changes, i2code implement first invokes Claude Code to triage the feedback and determine what changes, if any, are needed to address it. The i2code implement command invokes Claude Code one or more times to generate commits that address the feedback and pushes the changes. It also responds to the comments and review with an explanation of the changes.

3. Implement the next task in the plan. The i2code implement then takes the next task in the plan, and invokes Claude Code to implement it using TDD, creating a commit.

4. Push the commit and, if necessary, create a pull request.

5. Wait for the build to complete and repeat.

6. Mark the pull request as ready for review. Once all the tasks in the plan have been implemented, i2code implement marks the pull request as ready for review.

7. Wait for the comments or reviews. The i2code implement command can wait for comments or reviews on the pull request, and respond to them as described in step 2.

Trunk mode

The i2code implement command also supports a trunk-based development mode, where instead of creating a pull request, it commits directly to the current branch.

To learn more

Take a look at the design document for i2code implement in the Humans in the Loop Dev repository.

What’s next

In the next post, I’ll describe how i2code implement can execute Claude Code within a sandbox environment, which minimizes the security risks of using coding agents.

Need help with modernizing your architecture?

I help organizations modernize safely and avoid creating a modern legacy system — a new architecture with the same old problems. If you’re planning or struggling with a modernization effort, I can help.

Learn more about my modernization and architecture advisory work →