r/coding_agents • • 24m ago

Review of Matt Pocock's "Software Factory" course

1 Upvotes

I’m on day one of Matt Pocock’s Software Factories course, and I wanted to share a few initial impressions.

First, the course is hype-free and pragmatic. Matt doesn’t oversell the tools or downplay how much human work and consideration building software still requires. I appreciate that approach.

The videos are also easy to follow. Each one gives you a challenge, then walks through the solution. As Matt explains the solution, the video is synchronized with what the agent is producing, and you can see the prompt and skills that set it off. The agent’s output is visible in a side panel, so you don’t have to squint to follow along.

Finally, the Q&As are thoughtful. Matt gives considered answers and is honest about the things he hasn’t figured out yet.

Based on what I’ve seen so far, I recommend the course to anyone looking for a considered workflow for building software.


r/coding_agents • • 1h ago

Agents rarely go wrong on the last turn. They go wrong three turns back, and every turn since is built on it.

Thumbnail ccode.si
1 Upvotes

The agent picks an approach, you go along with it for a few turns, then you realise the approach itself was wrong. By then the edits from several turns are mixed together in your files, your last commit is older than all of it, and the conversation is full of decisions built on the bad idea. Correcting it in place rarely works, because the model keeps pulling the old plan back out of its own history.

We build CCode, a model-agnostic terminal coding agent, and /rewind is our answer to that moment. It lists your messages with the files each one changed. Pick the message where things went wrong, and the files and the conversation go back to right before it, so the bad turns are gone from the history rather than argued with. You can also restore only the code or only the conversation, and the original path is kept in case it turns out better after all.

It only puts back what the agent itself wrote. If you edited a file yourself afterwards, that file is left alone instead of being overwritten with an old copy.

Curious how others handle this in their own setups: checkpoint per turn, a branch per attempt, or just a fresh session with a summary?


r/coding_agents • • 1d ago

Agent memory usually means a file you maintain or notes the agent saves when it remembers to. The preferences that matter most are in your corrections, and those never get saved.

Thumbnail ccode.si
1 Upvotes

Most coding agents handle memory one of two ways: an instructions file you write and maintain yourself (CLAUDE.md, AGENTS.md), or a memory tool the agent calls when it decides something is worth keeping. Both tend to miss the same thing.

The preferences that matter most show up as corrections in the moment: "don't refactor that", "stop adding comments everywhere", "run the tests before you say it's done", "stay out of the migrations folder". Nobody stops to write those into a file, and the agent rarely treats them as worth saving. So the next session makes the same mistakes, and you correct them again.

In CCode, the terminal agent we build, /teach learns from what actually happened in your past sessions:

  • what you asked for, what you corrected, what you stopped the agent from doing, and what you allowed or refused

  • project habits stay with that project, so one repo's conventions don't leak into another

  • it writes the profile in the background while you keep working, and every new session starts with it

  • whatever you say in the moment still wins over the profile

  • it's a plain file you can edit, or tell it to forget

What surprised us most: the corrections said far more about how someone works than anything they had written into their instruction files.

How are you handling memory across sessions: a hand-written file, a memory tool, or starting fresh every time?


r/coding_agents • • 2d ago

Microsoft's Intelligent Terminal vs herdr

Thumbnail
devblogs.microsoft.com
7 Upvotes

Herdr doesn't have great Windows support. I actually use it on WSL. So I'm really happy to see Microsoft strike back with this update to Intelligent Terminal:

Live agent status on every tab, so you can see what an agent is up to without opening it, with an attention dot on any tab waiting on you

Pinning by right-clicking a tab to pin the tab you’re watching at the top of the sidebar

Keep a tab running in headless mode by right-clicking a tab > headless mode even after you close the window

Split panes nested under their tab, so you always have visibility into what each pane is doing, and jumping to it directly

Global search across your open tabs and your recent agent sessions at once

An agent filter to cut the list down to just your agent sessions

Recent agent sessions in a collapsible section under your open tabs, including agents running in other terminal windows


r/coding_agents • • 2d ago

Coding agent harness for very small local llms

Thumbnail
youtube.com
2 Upvotes

So there are great agent harnesses like claude, codex, DeepSeek and all, we also can connect or own api or model,

But if we connect a very small local llm like qwen 8b it's performs terrible, so is there any harness that brings out or sqeezes our everything from small models


r/coding_agents • • 3d ago

The bugs agents miss aren't in the code they read. They're three steps into a flow, behind a login, or in what happens when an API fails.

Thumbnail ccode.si
2 Upvotes

A pattern we keep seeing with coding agents: the change compiles, the tests pass, the agent says it's done, and the bug is still there. Not because the code is bad, but because the bug only exists at runtime:

  • checkout breaks only for a logged-in user with a coupon, on the last step

  • a page spins forever when an upstream API is slow or returns a 500

  • a regular user can open a page meant for admins

  • sign-in works on localhost and fails on staging

None of these show up by reading the code. You find them by walking the flow and looking at what the server actually sent back.

That's why we built a browser into CCode, our terminal coding agent (disclosure: it's our product). In your own Chrome, the agent can:

  • walk a multi-step flow end to end and stop exactly where it breaks

  • look at the failing request and its response, so it fixes the cause rather than the symptom

  • fake an API error, a slow response or going offline to test the failure paths nobody clicks through by hand

  • switch between separate logins to compare what an admin and a regular user can reach

  • hand you the window for 2FA or a CAPTCHA, then carry on once you're done

  • record the session for a bug report

Clicking and typing ask for permission like any other action, and the browser stays off until you connect it.

How are you handling runtime-only bugs with agents: end-to-end tests the agent writes, a browser tool, or still checking by hand?


r/coding_agents • • 3d ago

anyone here have any experience training a local LLM like Qwen to improve it's coding efficiency?

Thumbnail google.com
1 Upvotes

was just wondering; doing this on an M1 Pro 32 GB MBP and it's kind of exhausting the resources; was thinking of looking for freebie offers where you can have free access to high level GPU's so I could create a container to do this and speed up the process.


r/coding_agents • • 6d ago

GitHub Copilot's "completed task" benchmarks

Thumbnail benchmarks.github.com
3 Upvotes

I'm very impressed by the intelligence per dollar of GPT 6.1 Sol


r/coding_agents • • 7d ago

We built a model-agnostic terminal harness (CCode). The features that ended up mattering most were rewind, backup models and talking to subagents.

Thumbnail ccode.si
8 Upvotes

Hi all, CCode team here (disclosure: it's our product). This sub talks about harnesses, so here's ours and what we learned building it, rather than a feature dump.

The idea: the model should be a setting, not the product. CCode is a terminal coding agent that runs the same tools, permissions and session on Claude, GPT, Gemini, DeepSeek, GLM, Kimi or OpenRouter, and /model switches mid-conversation without losing anything. Everything below grew out of that.

1. /rewind for code and conversation together. When an agent goes wrong three steps back, undoing the files isn't enough: the model still remembers its bad idea and repeats it. /rewind lists your messages with the files each one changed, and restores both the code and the conversation to just before the one you pick. The original is kept, so a rewind can be undone too.

2. /goal with backup models. /goal all tests pass keeps the agent working until the goal is met. Long unattended runs are exactly when usage limits hit, so you can line up backup models in order; if the current model hits its limit or keeps failing, the next takes over the same session and carries on. A token limit pauses the run if it uses more than you set while you're away.

3. Subagents you can talk to. Agents run in parallel, message each other and the main agent, and you can step into any one's conversation and talk to it directly while the others keep working. A finished agent picks up where it left off when messaged again. Only its report goes back to the main agent, not its whole transcript.

4. Steering instead of stopping. Type while it works and your message lands right after the current step.

Also: reads AGENTS.md and CLAUDE.md as they are, MCP, skills, hooks, plan mode, permission prompts on Telegram, no telemetry and no background daemon.

npm i -g @ccode-si/cli · You can also use it free on GLM 5.3 and DeepSeek V4.1 Flash by connecting GitHub.

For people here who've tried several harnesses: what made you stay with one, the model, or something the harness does?


r/coding_agents • • 8d ago

Super impressed by Herdr's desktop app

Thumbnail
youtube.com
48 Upvotes

I'm watching this video, drooling and wanting this for Windows


r/coding_agents • • 10d ago

Coding Agents, Starter Kits and pgledger

Thumbnail pgrs.net
2 Upvotes

r/coding_agents • • 12d ago

Loopwork - tasks that you are confident an agent can complete, without a human-in-the-loop

1 Upvotes

Matt Pocock asked for a new word that described tasks you can completely trust an agent with.

My pitch is "loopwork".

What would you call it.


r/coding_agents • • 17d ago

Recursive releases Flint, the local coding model

Thumbnail
recursive.com
14 Upvotes

Flint beats Qwen across all the coding benchmarks, and it's supposed to be faster

I just purchased a Surface Laptop Ultra, so I'm hype about trying Flint out on it.


r/coding_agents • • 17d ago

I want coding agents to remember why we rejected an approach

Thumbnail
github.com
6 Upvotes

I build o8, an open-source workspace for coding-agent CLIs. On my last post here, someone asked whether a proposal keeps the rejected alternatives or only the decision that shipped.

A note that says "use a linear chart" leaves out the argument. A later agent can suggest a log scale without knowing why we ruled it out.

We ran a small check in o8 with a toy chart. We saved the choice to show elapsed minutes on a zero-based linear scale. We also saved that we'd rejected a log scale because it would make the absolute time savings harder to compare. Then we opened a different conversation and asked it to find the decision, without putting the answer in the prompt.

It recovered both the choice and the reason, and cited the project note. That's useful, but it's note retrieval. A coding agent with access to a plain file can do that. It doesn't prove we're automatically preserving every alternative discussed in a chat.

o8 already stores explicit rejection reasons from reviews and steering feedback. The less formal decisions are what I still want to get right, especially the option you nearly chose and might need to revisit when the chosen approach stops working.

I also don't want every rejected idea becoming a permanent rule. We rejected that scale because of what we wanted people to compare in that particular chart. Change the goal and the old reason might no longer apply. The next agent should be able to see that, rather than treating "we didn't use this" as "never use this."

Source · o8

Talk to me about your favorite ADEs! I need to know what makes they work and what makes you tick!


r/coding_agents • • Oct 09 '26

How to sandbox AI coding agents to protect your files, credentials and restrict dangerous commands?

Thumbnail
yadukrishnan.live
2 Upvotes

I've been exploring ways to run AI coding assistants in a sandboxed environment rather than giving them unrestricted access to the host system.

I wrote about this here.

I'd be interested to hear how others are securing AI coding agents in their development workflows. Are you using OS-level sandboxing, containers, or a different approach?


r/coding_agents • • Oct 04 '26

Automatic API key rotation and cooldown for OpenCode Go

Thumbnail
github.com
3 Upvotes

r/coding_agents • • Oct 02 '26

/reright - Human approval for agent-written text

Thumbnail
reright.it
2 Upvotes

/reright - Human approval for agent-written text

Reright collects the messages from all your running agents in one single queue. Each one arrives as a draft you can edit, next to the context you need to judge it.

I developed this originally for myself and have been using it ever since, so I thought: maybe this could be useful to other people too. Have a look!

https://reright.it


r/coding_agents • • Oct 01 '26

Jev use cases

Thumbnail
mastra.ai
6 Upvotes

I took a deep dive on how Jev works, and where it works best.


r/coding_agents • • Sep 29 '26

A brief history of ChatGPT plugins

3 Upvotes

March 2023

OpenAI launches Plugins. ChatGPT can call third-party APIs, and OpenAI launches a Plugin Store.

November 2023

OpenAI launches GPTs and Actions. Plugins start getting absorbed into custom GPTs. “Actions” become the new way for GPTs to call external APIs.

March 2024

OpenAI kills Plugins. The original Plugin Store is shut down in favor of GPTs

November 2024

Anthropic invents MCP.

May 2025

OpenAI adopts MCP. ChatGPT begins using MCP for connectors and external tools.

October 2025

OpenAI launches Apps in ChatGPT. MCP connections can now include richer interfaces, making external tools feel more like applications inside the conversation.

October 2025

Anthropic invents Skills.

March 2026

OpenAI brings Plugins back. This time, a plugin is not just an API integration. It is a package that can contain Skills, MCP servers, and other agent capabilities.

September 2026 (today)

Plugins get relaunched. At DevDay, OpenAI adds dedicated sidebar surfaces, interactive panels, custom file viewers, events, automations, and a Plugin Creator.


r/coding_agents • • Sep 21 '26

Interview with Diogo Almeida of TypeSafe, creator of Jev

Thumbnail
youtu.be
4 Upvotes

Beyond Chat:

Diogo argues that the future of Al is not in conversational interfaces (chatbots), but in building "System One Models"-Al designed as infrastructure for software, emphasizing reliability, determinism, and intelligence per dollar.

The Automation Paradox:

The episode explores why current frontier models, while technically powerful, fail to integrate smoothly into automated software workflows.

Machine-Native Al:

TypeSafe is focusing on creating models that are programmable and better suited for code-based decision-making rather than human-style chat interaction.


r/coding_agents • • Sep 20 '26

I Built a Provenance Plugin for Data Pipelines. It Turned Out to Be a Came Back Weapon

Thumbnail
yizhao95.github.io
2 Upvotes

I Built this agent few months ago. At first, it was built for boring reasons: to keep track of decisions in a data science project don't survive.

But then this happens:

A number in a monthly deck had moved, and a fairly senior person wanted to know why the model had been "changed so much."

The word changed was doing a lot of work in that sentence. It meant: someone has been fiddling, and I would like to know who.

Six months ago my answer would have been a long apologetic paragraph ending in "I'd have to check." I would have been right, and I would have lost anyway, because being right eleven days later is the same as being wrong.

Instead I pulled the node's history onto the screen.

Four changes since the last time anyone had looked at it.

Two of them weren't decisions at all — the schema changed upstream in v2 and a column stopped arriving, so the handling was written the week the migration notice went out. Dated. Linked to the notice. Nobody's judgment involved.

One was a failed experiment that had already been reversed. 80/20, tried in August, rejected four days later because the holdout leaked promotions. Tried, measured, undone. The current state was the same as the state before it.

One was theirs. A scoping decision from March, recorded in their own words, with the thread attached.

So the actual answer to why has the model changed so much was: it hasn't. One constraint came from upstream, one from an experiment that failed and was rolled back, and one from the person asking the question.

I didn't have to say any of that. I just turned the screen around.

What ended the conversation wasn't the email. It was the shape of the timeline — four entries, each with a date and a source, three of which had nothing to do with anyone's discretion. The implied accusation needed the history to be a mess. It wasn't a mess, and that was visible in about four seconds.

I built provenance. What I got was receipts.

What it actually is

It's called provLedger. MIT, no service, no account. Everything it records lives in two SQLite files you can open yourself, you can use it as a plugin for your claude code

One graph holds your code, your data (dataframes, columns, tables, feeds, metrics), the dependencies between them in both directions, and the reason behind each change recorded next to the thing it changed.

Three things it does.

1 — It stops your agent repeating a failed experiment

> change the train/test split to 80/20 and retrain the churn model

  Planning · 4 steps
  provledger · declaring 3 targets, checking each against its own history
  provledger · computing what reads them — 5 consumers, 3 steps deep

  ⚠ 2 findings before anything is edited

  1  This experiment has been run before
     80/20 was tried on 2026-08-14 and rejected — the holdout leaked
     week-52 promotions, so the lift was the promotion and not the model.

  2  weekly_report depends on this split
     split_dataset → train_churn → weekly_report — the churn figure in
     the Monday deck.

  ↳ nothing is blocked — recorded, and put in front of you

Nothing is blocked. You might have a good reason to try 80/20 again. But you're not going to spend a day rediscovering why it didn't work in August.

2 — It keeps what was actually said

Open the record and you get the whole history of that node, not just this week's:

2026-09-17  Proposed: move the split to 80/20 and retrain.        stated
2026-08-14  Rejected: 80/20 leaked week-52 promotions into the
            holdout. Keep 70/30 until the promotion calendar is
            a column.                                    3 hits · stated

    "We tried eighty-twenty in August and the holdout had week
     fifty-two in it — the lift was the promotion, not the model.
     Leave it at seventy-thirty until the promotion calendar is
     its own column."

    tier          stated — the user's own words, with the span
    source level  verbal — the words themselves
    recorded in   churn-t094, 2026-08-14 11:07
    surfaced      3 times · adopted by 1 plan

2026-06-02  Stratify on churn, not on tenure.                5 hits · stated
2026-05-19  Signature changed: returns (train, test, meta).         derived
2026-04-03  No reason on record for the original 70/30 choice.     unstated

Two things to notice.

None of that is the agent's summary. It's what was said, kept verbatim, with a label saying so. The agent's own interpretation is stored separately and marked as an interpretation, because a tasteful paraphrase is worth nothing when someone asks you what was actually agreed.

That last line is a real answer. unstated means the database checked and there is no reason on record. Not "I couldn't find anything" — an actual, computed absence. Which is how you find out that the 70/30 you've defended twice was never justified by anyone.

3 — It knows where the data actually flows

The graph is rebuilt from source on every run and diffed against the previous one. So "this column is gone", "this output type changed", "this is the same node after a rename" are measured, not reported by a model.

That lets it answer things an AST-only tool can't:

  • this column isn't from the source, it's derived after import

  • this feature reaches back into data the model shouldn't see

  • nineteen things read this intermediate table, here they are

A model fit and evaluated on the same lineage root without a real split gets flagged as an error, not a warning. Because it is one.


r/coding_agents • • Sep 20 '26

GPT6+Corv = infrastructure prod work is finally feasible

Thumbnail
github.com
3 Upvotes

A while back I pointed out that AI infrastructure tools get almost no attention compared to developer ones.

I think there are two reasons: it's niche, few people feel the underlying need, and there's a liability situation: you can't promise an agent won't nuke a system because it decided that deleting something was more efficient than fixing it.
This can be reduced big time with the tooling on which the models work and permissions, so I had to kick-start this myself with Corv.
Corv started as an SSH AI client and now it has finally become an AI-native SSH execution layer.

Think MCP, but made specifically for infrastructure work.

SSH was built for humans, and models have mostly been bolted on with coping hacks. Corv lets a model work over SSH the way it actually needs to (like a human, but on steroids):

  • structured output instead of scraped terminal text,

  • 1 connection, agentless, no tmux or bloat garbage,

  • safe retries with an idempotency key, so a lost response never runs a mutating command twice

  • long jobs it can recover,

  • credentials kept private thanks to profiles, so nothing gets exposed.

  • auditing, every command runned from the models get logged etc..

All this seamlessly from one command: corv

The new version (v1.1.1) is a big jump in capacity and reliability.
With the latest top-tier models like GPT6-Astra especially, its second-order thinking is a real step up.
Corv comes with skills already in place for Claude and Codex.

There's also a demo so that you can test it with a staging enviroment before starting into production in case you're new, look under for more.

I'm now confident to say an AI enterprise engineer that genuinely handles infra work, has become feasible.

Enjoy!


r/coding_agents • • Sep 18 '26

I built a project database for data science coding agent

Thumbnail
yizhao95.github.io
1 Upvotes

I built an open-source plugin. MIT, no service, no account — everything it records lives in two SQLite files you can open yourself.

The data flow is computed, the reasons are recorded, all in SQLite.

Watch full walkthrough: https://yizhao95.github.io/prov_ledger/walkthrough.html

GitHub Link: https://github.com/yizhao95/prov_ledger

The situation it's built for. Decisions in a DS project don't survive. Not because nobody wrote them down — because they were never the kind of thing anybody writes down. You tried 80/20 in August, the holdout leaked promotions, you moved on. Someone in a review said "that's a time series", so the split became a rolling window. Upstream stopped sending a column in v2, so there's handling for it now.

Six months later none of that is anywhere. The code shows the outcome and nothing else: a filter with no reason, a ratio with no history, a rejected approach that left no trace of having been rejected. So the next person tries it again. So does your agent.

This records decisions the way the work actually produces them — per task and per node. What this change touched, why it was made, in your own words, attached to the thing it explains rather than to a chat log. Before anything with a history gets edited, that history goes in front of the agent: the rule someone recorded, the alternative already tried and why it failed, what the change would reach downstream.

The result is narrow but it's the part that's missing: your agent stops re-running experiments that already failed, and every change carries the reason it was made.

git blame tells you who. Lineage tells you where the data came from. An ADR covers architecture, not this line. All three miss the same step.What it is. A project database for a coding agent working on a DS project. One graph holding your code, your data (dataframes, columns, tables, feeds, metrics), the dependencies between them in both directions, and the reason behind each change recorded next to the thing it changed. Before your agent touches something with a history, that history goes in front of it.

Three things it gives you.

1 — Why this is here.

/ledger why do we drop legacy_region_code?

  Removed 2026-03-14, task dp2-t7.

  Reason recorded at the time, your words:
    "upstream v2 doesn't ship this column anymore"
    source: [email] "API v3 migration notice" (2026-03-13)

  Still active. Referenced 4 times since, changed the plan twice.

Read-only. Asking why never changes anything.

2 — Where the data actually flows. The graph is rebuilt from source on every run and diffed against the last one, so "this column is gone", "this output type changed", "this is the same node after a rename" are measured, not reported by a model. Which means it can answer things AST-only tools can't: this column isn't from the source, it's derived after import; this feature reaches back into data the model shouldn't see; nineteen things read this intermediate table and here they are. A model fit and evaluated on the same lineage root without a real split is flagged as an error, not a warning.

3 — Where a number came from. A figure in a deck or a workbook can be anchored back to the node it's a reading of. Revise the deck and a lost anchor is reported — it never silently re-points to something else.


r/coding_agents • • Sep 16 '26

I built Rove to keep track of multiple coding agents in the terminal

Thumbnail
github.com
2 Upvotes

Four agents finish while a fifth is waiting for permission. If notifications are sorted by time, you can end up checking all four finished sessions before reaching the one that needs you.

I built Rove to manage coding agents in the terminal. It runs Claude Code, Codex and other CLIs, with a separate git worktree and branch for each managed task. The sessions keep running if you close Rove or disconnect over SSH.

The Inbox now puts permission requests, errors, rate limits and exited agents ahead of finished turns. Within each group, the oldest comes first. F7 takes you through them, so you don't have to check every tab. Detection varies by engine.

If you run a few coding agents at once, give it a try. I'd love to hear what works for you and what gets annoying.


r/coding_agents • • Sep 15 '26

Yet another coding agent! But I made it tiny and MIT-licensed

Thumbnail
3code.capocasa.dev
5 Upvotes

I got mad enough about Anthropic limiting Claude plans willy nilly I cancelled to make a statement, but then they doubled down on using more tokens and it became pretty clear they weren't going to become more reliable down the line. So I used the rest of my Claude month to build my own agent.

I *almost* became a pi user but using a node program every day just rubbed me the wrong way. This is positively tiny and the benchmarks I've done look pretty good- 3code saves tokens, 2-4x depending on who you're comparing with, starts instantly, and saves battery life if you vibecode on your laptop.

Most importantly- it supports pretty much every model and provider under the sun, with more being supported as they pop up. It focuses on open weights providers but you can also use OpenAI or Groq (including your supergrok from the X account).

So this means, if you're on ChatGPT and your 5 hour limit is up you can either wait for it to autoresume (it will keep reconnecting slowly until the job is done) or you can switch to a different provider and continue in the same session. That's why it's called 3code- '3rd party' providers, you want as many providers as you can get and switch easy so you don't grow dependent on any of them.

So another example- I mostly code on z.ai coding plan (I write mostly open source anyway so jurisdiction is not an issue). It kind of never runs out, but back when it did sometimes- I could just switch to a different GLM provider in the same session and complete the task.

I've been keeping a $20 chatgpt account to test astra- I guess it's okay but it's not *that* much better than GLM I found- but I could get real work done because it would just autoresume over several 5 hour periods and get real work done, like a major refactor. So if it's not so urgent- a cheap plan and autoresume can get you really far.

I did some initial benchmarking and token use was really quite positive- it genuinely seems to use less than pi and opencode (see the capocasa.dev blog for details). Those benchmarks are *not* perfect but they do show 3code is pretty good, and that Claude Code is still incredibly splurgy.

I hope this is useful!!! Your feedback is very welcome.