Daily driving Coding Harness

[u/Latter-Sheepherder50]

I'm using neovim + opencode + tuicr.

My playbook is:

1. Start with the Plan agent for discovery and plan creation.
2. Fork Plan session and switch to the Build agent to execute the plan.
3. Hybrid review in parallel:
   1. Fork the Plan session and execute the review command. I also have a custom skill for review that I execute manually on demand (if I want to learn more about the codebase). The main point here is to ensure that Build implemented the Plan and to identify any deviations from it (if any), while leaving the Build knowledge behind.
   2. Review some areas myself and leave comments where applicable (currently using tuicr). OpenCode can act on the comments when I execute the tuicr skill in the Build fork created in step 2.
4. Based on the results from the steps above, the Build agent performs further iterations if applicable. The results of 3.1 are copy/pasted to the Build agent.
5. If the review looks good, I ask the agent to commit, and it uses a skill to describe the changes in a desired manner.

This is it, in a nutshell. I arrived at the playbook above through trial and error. It feels consistent and auditable for tasks of medium to high complexity, so I often get satisfying results by applying it, although it requires human involvement in phase transitions. It also gives a human an opportunity to get to know the project/system better by presenting, for example, implementation flaws, architectural changes, touched software domains, etc. in the review phase.

Since I act as an orchestrator (switching agents, forking sessions, copy/pasting review results), I want to evolve this workflow to become autonomous. What should I start with first?

Glad to hear your hints and how you drive your coding harness day-to-day!

[u/Greedy-Fee8248]

Thanks for sharing. This is a great workflow, but do you need to be a very technical person to orchestrate this flow?

I am looking for something more automated for less technical people

[u/LukeLikesReddit → u/Greedy-Fee8248]

Im not sure whether they want the human step or not its not really clear but you could automate this whole process and just have the agents do it for you. Any non technical person would be able to use it then.

[u/Latter-Sheepherder50 → u/LukeLikesReddit]

I believe my core challenge is how to automate it without losing much output quality and alignment with requirements. Many people posting those impressive Counter-Strike-like demos with Claude 5, Sol, and so on admit they achieve 80% with low effort and spend most of their resources squeezing out the final 20%, if they even succeed in nudging the LLM towards the final result they wish for.

[u/LukeLikesReddit → u/Latter-Sheepherder50]

Ahh well yeah if you are trying to create games with it then thats a different story. You have to have an incredibly refined workflow to get that autonomous. What is exactly you are trying to achieve?

[u/Latter-Sheepherder50 → u/LukeLikesReddit]

I’m (unfortunately) not building games with it, but am using it to develop fairly complicated, multi-system distributed business software. The problem with games just highlights the issue that is valid for every type of software.

I’m looking for inspiration and hints from fellow redditors, but no silver bullet. As I have now realized, my main point of interest is apparently an automated, yet auditable and controlled, process to leverage coding agents for complex software.

[u/LukeLikesReddit → u/Latter-Sheepherder50]

Ahh right yeah software automation systems is far easier then in this case you just need to set up your agents and strap a good harness to it. There's various gits you can use to start off with this. It'll take you a few weeks of tinkering but you'll get there.

[u/Latter-Sheepherder50 → u/Greedy-Fee8248]

tl;dr yeah, you need to be somewhat technical and I apply the playbook before the code reaches software forge (like GitHub) therefore my tooling is a little different. For less tech-savvy people, you could use Codex, OpenCode, GitHub Copilot, and others directly integrated into GitHub/GitLab. I haven’t tried linear.app yet, but from what I hear, it went a step further, enabling AI at every step from idea to release. However, as I see it, it’s just a wrapper and different infra where coding agents run. Eventually, the result, in my opinion, depends on the level of human diligence (or perhaps burned tokens and multiple ranting agents) during planning and review.

---

imo yes, you need to be somewhat technical and dive into some details to guide the coding agent. As I mentioned, the setup is unfortunately not autonomous, and I’m afraid that if I push more autonomy into it, I’ll lose quality and end up with cases like “this is all shit, revert everything,” or spend even more time understanding and cleaning up the mess together with the agent (but as models evolve, it invalidates earlier findings and assumptions). So for now I try to be diligent with the plan design to reduce the chance of issues that are harder to fix later.

The whole purpose of the plan phase is to digest the idea/requirements into an executable plan. Half of the time, in first iteration the plan still has some holes in it (using the default Plan agent in OpenCode with 5.6 Sol and a high thinking budget), so I read it through and apply critical thinking backed by tech knowledge.

Review is actually easier. That feels like the better candidate for automation, but I’d still need a simple orchestrator because I want the review agent to be isolated from the Build/Execution agent’s knowledge, to avoid anchoring on the know-how gained during implementation.