# Agentic SDLC, Part 2 — The Agent Finished Before I Could Reply

**Summary:** A GitVibe run finished before I could reply. I compare local sessions, hosted sessions, and GitHub-triggered jobs, and show how I correct a live run or carry decisions and test results into the next one.

- Canonical: https://markhuang.ai/blog/agentic-sdlc-part-2
- Language: en
- Author: [Mark Huang](https://markhuang.ai/about)
- Published: 2026-11-18
- Section: Tutorials
- Tags: agentic-sdlc, ai-agents, coding-agents, code-review, github-actions
- License: https://creativecommons.org/licenses/by-nc/4.0/

---

![A hand moves a model railway switch just ahead of a red locomotive](https://cdn.markhuang.ai/blog/agentic-sdlc-part-2/hero.webp)

*The switch is still within reach before the train enters the fork. Conceptual illustration.*

I wanted GitHub issues and pull request comments to be how I talked to GitVibe. I'd be typing a correction, and by the time I was ready to post it, the job had already finished. The next session could read the comment and inspect the code. I still had to piece together why we'd made the earlier choices so the next agent knew what to keep.

In Part 1, I asked what success looks like, how I'd test it, and how I'd keep the product working. Once I put an agent into that software development life cycle (SDLC), I have another decision to make. Where should the work run, and how do I get a correction to the agent when I see it going in the wrong direction? [Agentic SDLC, Part 1](/blog/agentic-sdlc-part-1)

While I'm still making decisions, I prefer a local session I can interrupt. If I need work to continue after I close my laptop, I'd use a remote runner that lets me get back to the same session or gives the next one enough context to pick up where it left off.

## Where I run the loop

With GitVibe, I tried running the agent through different SDKs, including Vercel's AI SDK and tools from Anthropic and OpenAI. In v1, GitHub Actions ran implementation, tests, review, and pull request creation. A separate workflow could take PR feedback and update the branch. The project later removed the stages that wrote code. [GitVibe v1 workflows](https://github.com/markhuangai/git-vibe/tree/v1.0.0#workflows) · [Removal of code-writing automation](https://github.com/markhuangai/git-vibe/pull/57)

By *local*, I mean the machine where the agent edits files and runs commands. With a terminal app like Claude Code, Codex CLI, or Gemini CLI, I can see what the agent is running in the session. Claude Code, for example, can pick up both my personal instructions and the project's `CLAUDE.md`. That's useful when I already know which instructions to change and have the tools and service access set up. [How Claude Code loads instructions](https://code.claude.com/docs/en/memory)

| Setup                     | What keeps running                                    | What the agent can use                                                                              | Where my correction goes                                                                               |
| ------------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| Local CLI                 | My machine has to stay on and awake.                  | My checkout, personal and project instructions and skills, and configured tools and service access. | I can interrupt and redirect the active conversation.                                                  |
| Persistent hosted session | The remote host keeps working when I close my laptop. | A remote checkout and whatever tools, instructions, and access I configure there.                   | I can send a follow-up to the same session. The client may queue it until the current action finishes. |
| GitHub-triggered job      | A runner executes the job while my laptop is off.     | The checkout, configuration, and credentials the workflow gives it.                                 | In GitVibe v1, a PR comment with a command could start a follow-up job.                                |

I can run a few local sessions at once in separate Git worktrees. Each worktree has its own checked-out files, so agents can work on different branches without editing the same copy. If I step away, I can reattach to a persistent terminal over SSH or open the session from my phone with Paseo. I'm still connecting to the machine where I started the agent. [Git worktrees](https://git-scm.com/docs/git-worktree) · [Paseo](https://github.com/getpaseo/paseo)

Claude Code on the web can keep a cloud session running when my laptop is closed and accept follow-up instructions in that session. If I need the agent to stop before it takes another action, I'd check whether the client interrupts the current action or queues my message. [Claude Code cloud sessions](https://code.claude.com/docs/en/claude-code-on-the-web)

## How I interrupt a run

Take the hypothetical saved-item app from Part 1. I should be able to save an item, reload the page, and find the same content again. Suppose I see the agent adding accounts. In Claude Code, I'd press `Esc` to interrupt the current action, then look at the diff. The files it already edited are still on disk, and I can correct the scope in the same conversation. [Claude Code interactive controls](https://code.claude.com/docs/en/interactive-mode)

> Keep this single-user. I need to save one item, reload the page, and find it again. Show me that test first.

If the job has already ended, I'd put the decision in the issue or PR and link the branch the next run should use. I'd explain that the first version has one user, so accounts can wait. Then I'd link any test results we have and leave the outstanding check in full. The next run needs to save an item through the app, reload, and verify that the original content comes back from real storage.

## What I want to decide before coding starts

I'd start with a planning skill in the CLI I already use. A skill gives the agent a set of instructions to reuse. I'd use it to work through the feature with me and leave the agreed scope, reasons, and acceptance criteria in a plan file or a Jira comment. If a correction changes the scope, I'd update that same record. I'd link it from the PR so a teammate can see why the change looks the way it does. [Claude Code skills](https://code.claude.com/docs/en/skills)

Once I agree with the plan, I can hand off most of the work. The agent can implement the change, run unit and end-to-end tests, and open a PR with the results. A Claude Code hook can run a command after an edit or notify me when the agent needs input. I want CI to run the required checks on the PR and keep the actual test output. If a check fails, the agent can look at what went wrong, fix it, and rerun the check. [Claude Code hooks](https://code.claude.com/docs/en/hooks-guide)

Review is where I'd deliberately use a fresh session. I'd give the reviewer the plan and the diff so it can check what we agreed to build against what the PR actually does. My AI PR Reviewer can run separate review sessions with different goals, such as looking for regressions or examining the test coverage, then combine their findings. I can also ask another developer for a peer review. The agent can address findings and run the checks again. If a fix would change the behavior we agreed on, I want the agent to ask me before it proceeds. [AI PR Reviewer](https://github.com/markhuangai/ai-pr-reviewer)

I want to spend most of my time with the agent on the plan. Before I leave a new setup running on its own, I'd try interrupting a small task on purpose. Then I'd open a fresh session with the written plan, branch, and test results and ask it what it would do next. If I have to explain the same decision twice, I know what to write down before handing off a bigger task.
