Keeping Claude in the Loop

A lot of work starts in a meeting, gets mentioned once, and then drifts off into whatever follow-up system someone remembers to use. We've been trying a different setup at Ariso: Ari captures the meeting context, and that context surfaces later — in Claude Code, when I'm actually building.

Here's how that went last week.

On Tuesday, in a regular product meeting, we spent about ninety seconds on an annoying bug: Ari's verify node was marking tasks as fulfilled even when the underlying tool calls had failed. Someone said "we should make the verify prompt require a retry before it calls something done." Everyone nodded. We moved on.

Nobody wrote a ticket. Nobody opened Jira, because we don't have Jira. Nobody even wrote it on a sticky note.

This morning I opened a terminal, typed claude, and before I asked for anything, Claude Code greeted me with a short list of suggested tasks. Task 1:

Update verify node prompt — Update Ari's verify node prompt to require that failed tool calls are retried before being marked as fulfilled.

I typed "1". Five minutes later there was a PR.

That's the whole workflow. Let me show you the seams.

Step 1: Say it out loud

Ari sits in our meetings and takes notes — not transcription-as-a-feature, but notes that actually get parsed for decisions, action items, and follow-ups. When we talked through the verify node problem, Ari captured it the same way it captures everything else: who raised it, what the fix should be, and that it was small and bounded enough for an agent to take a swing at.

The important part: this took zero extra effort. Nobody "filed" anything. The meeting itself was the filing. The thing we talked about in the meeting doesn't just stay in the meeting.

Step 2: Open Claude Code

Here's where it gets fun. We run ari-hooks on our dev machines. It's a small open-source package that wires Claude Code (and Codex, and Cursor) into Ari using the hooks system the agents already ship with.

One of those hooks fires on SessionStart: when Claude Code boots, it asks Ari, "given everything you know — meetings, follow-ups, support threads, what shipped yesterday — what are the top things Claude could take care of right now?" and prints them into the session.

So the task from Tuesday's meeting didn't go to a backlog and wait to be groomed. It went to the exact place where work actually starts: the terminal, at the moment I sat down with coffee and an empty context window.

Reply with a task number or name, and Claude runs it as if you'd typed the prompt yourself. The prompt is already scoped, because it was born from a real conversation with real context — not reverse-engineered from a two-word ticket title three weeks later.

That's a pretty good feeling, honestly. You're not digging through notes or trying to reconstruct the conversation from memory. The task is sitting there with enough context to do something useful with it. You just start working.

Step 3: Ship it

Claude Code did what Claude Code does: found the verify node prompt, made the change, ran the checks, opened the PR. I reviewed it, we merged it, and the fix everyone nodded at on Tuesday was in production before anyone would have gotten around to writing the ticket describing it.

And the loop closes on its own, because ari-hooks doesn't just pull tasks down — it pushes outcomes back up. Every Claude Code turn, the hooks send the request and the final outcome (not the intermediate steps — nobody wants those) to Ari. So Ari knows the verify node task is done, stops suggesting it, and it shows up in the journal and the next standup context automatically.

Tell people what you're going to do. Do it. Tell people you did it. Except now "people" includes your AI, and it handles two out of the three.

Wait, no ticketing system?

I wrote before about how our open PRs are our board. This is the other half of that story: how work gets onto the board without a ticketing system in between.

A ticket, if you think about it, is a lossy compression of a conversation. Someone hears about a problem, summarizes it into a title and description, assigns a priority that will be wrong by Thursday, and drops it into a queue where it decays until someone rediscovers it and asks "wait, what did we mean by this?"

We already had the conversation. Ari was there. The full context — what's broken, why it matters, what the fix should be — exists in higher fidelity in the meeting notes than it ever would in a ticket. So why would we pay someone to manually degrade it into Jira?

The ticketing system's actual jobs were: remember the work, route the work, and report on the work. Ari remembers it (meetings, follow-ups, journals). ari-hooks routes it (straight into the coding agent's session). And the PRs plus Ari's journal report on it. Every job the ticket had, something better now does.

We don't use a ticketing system anymore. Not as a flex — we just kept not needing it.

The plumbing: ari-hooks

The piece that makes this work is deliberately boring, and it's open source: github.com/ariso-ai/ari-hooks.

That one command logs you into Ari (once per machine), detects which coding agents you use, and wires up the hooks. For Claude Code it adds three:

• SessionStart — fetches Ari's top suggested tasks and shows them when Claude boots; reply with a number to run one
• UserPromptSubmit — records what you asked for
• Stop — sends the request/outcome pair back to Ari when the turn finishes

It preserves your existing settings, running it twice is a no-op, and ari-hooks uninstall removes everything cleanly. Codex and Cursor get the equivalent hooks in their own formats. No daemon, no sidecar, no "platform." Just the hooks your agent already supports, pointed at the assistant that was in the meeting.

That's the bit I care about. Not "can we take notes better," but "can the thing we said in the meeting show up later, when it's time to build it" — with no manual handoff in between. ari-hooks is the repo that connects those dots.

The loop is the product

A lot of engineering work isn't slowed down by the work — it's slowed down by context loss. Someone hears the right thing in a meeting, writes it down somewhere, and later somebody else has to rediscover it. Even when the note is good, it still creates a gap between discussion and execution.

This setup closes that gap. Meeting context stays connected to the coding session. Claude Code gets something real to work from. The task moves faster because it doesn't have to be reintroduced every time it changes hands.

And here's the thing I keep coming back to: everyone is racing to make coding agents better at executing work, and they are getting genuinely great at it. But execution was never the whole job. The job was: notice the work, remember the work, start the work, finish the work, and tell everyone it's finished.

Coding agents nailed the middle. Ari plus ari-hooks closes the ends.

Talk about a problem in a meeting. Open your terminal. It's waiting for you there. Ship it. Ari tells the team.

And yeah — it's nice when you boot up your workstation and the thing you talked about an hour ago is already there waiting. No tickets were harmed in the making of this workflow, because no tickets were made at all.