# I built an unattended Claude Code loop that reviews PRs and works my Jira backlog

> Source: <https://dev.to/alvaroraul7/i-built-an-unattended-claude-code-loop-that-reviews-prs-and-works-my-jira-backlog-i43>
> Published: 2026-09-04 10:33:58+00:00

Every developer knows this Tuesday: you're deep in a bug, Slack pings with "can you review this PR?", and by the time you get back to your own code you've lost the thread. Meanwhile the Jira backlog sits there — every ticket in it legitimate, and every one losing to whatever's on fire that day.

``` php
flowchart LR
    S["Slack ping"] --> C1["stop coding"] --> R["review PR"] --> C2["lost the thread"]
    B["Jira backlog"] -.->|"loses to\nwhatever's urgent"| N["stays untouched"]
```

Neither task needs *me* specifically — just consistent judgment, on a schedule that doesn't depend on how busy I am. So I built `ultracode-live-engineer`

, a Claude Code plugin that wakes up on its own and handles both.

``` php
flowchart TD
    W(("⏰ Wake")) --> P1 & P2 & P3
    P1["👀 Slack Review<br/>mention + PR link → review"]
    P2["🔁 PR Follow-up<br/>fix feedback on own PRs"]
    P3["🎫 Jira Selection<br/>pick up a ticket"]
    P3 --> I["🛠️ Implement<br/>isolated worktree"]
    I -->|success| PR["✅ Open PR"]
    I -->|ambiguous| H["🚧 Escalate<br/>Jira comment + Slack DM"]
    H -.human replies.-> P3
```

One rule is non-negotiable: when it's not sure, it doesn't guess. Ambiguous cases get parked and handed to a human — never merged, never silently skipped.

I let it run and log every pass. 163 wake-ups later:

```
flowchart TD
    subgraph Totals["Zero interrupts to me"]
        direction LR
        A["32 PRs reviewed"]
        B["4 PR follow-ups fixed"]
        C["13 tickets moved forward"]
    end
```

Partway through, I noticed the "nothing to do" pass — the most common one — was the slow one. Three independent checks were running one after another instead of at once, and mechanical yes/no checks were each burning a full AI call. Fixing both:

```
flowchart LR
    subgraph Before["Idle pass — before"]
        direction TB
        d1["190s median"]
        d2["10 agent calls"]
    end
    subgraph After["Idle pass — after"]
        direction TB
        e1["79s median"]
        e2["7 agent calls"]
    end
    Before -->|parallelize + batch| After
```

58% faster, 30% fewer agent calls — for the case that happens most.

The industry numbers aren't about typing speed — they're about waiting to be noticed. LinearB's 2026 benchmarks (8.1M PRs) put average-team PR pickup at 4–16 hours before review even starts; SmartBear's review research puts a manual review session at 60–90 minutes once someone sits down with it.

```
flowchart LR
    subgraph Industry["Industry (LinearB / SmartBear)"]
        direction TB
        i1["Pickup: 4-16h average team"]
        i2["Review session: 60-90 min"]
    end
    subgraph Loop["This loop"]
        direction TB
        l1["Pickup: next wake (minutes)"]
        l2["Full pass incl. review: 8.5 min"]
    end
```

One honest twist: DORA's 2025 report found that as AI-authored code volume rises industry-wide, human review time has actually gone up 441%, and 31% more PRs merge with zero review. AI made writing code faster — it didn't remove the review bottleneck. That's exactly why the escalate-to-human rule exists here instead of an autopilot that just merges.

```
claude
/plugin marketplace add AlvaroRaul7/ultracode-live-engineer
```

Repo: [https://github.com/AlvaroRaul7/ultracode-live-engineer](https://github.com/AlvaroRaul7/ultracode-live-engineer)