Throughloop

AI that fixes engineering execution automatically. Detect → act → verify → improve.

Throughloop is the execution layer for engineering teams. It detects PR bottlenecks, sprint drift, and blocked engineers — then assigns reviewers, updates tickets, and notifies your team. Not a chatbot. Not a dashboard. An agent that closes the loop.

This repo is the YC application demo. Mock data, mock integrations, real UI.

---

The problem

Standups, retros, and dashboards are lagging indicators. By the time a human notices the drift, the sprint is already off-track. Most "AI for eng" products surface charts; none of them act.

• Reviews stall — the same 2 seniors carry the queue
• Sprints drift — scope creeps quietly until Thursday
• Juniors get blocked — silently, on senior bandwidth
• Postmortems lag — action items rot in a doc

The solution

Throughloop is a closed-loop agent:

1. Detect — watches PR queue, ticket flow, Slack signals
2. Reason — pinpoints the actual cause (overloaded reviewer, scope creep)
3. Act — executes the fix with safety guardrails
4. Verify — re-checks the metric, escalates if needed

The MVP ships one killer workflow: PR Review Recovery. Three more are queued.

---

Demo flow

1. Open the landing page (/)
2. Click View Demo Dashboard → land on /dashboard
3. Click Run YC demo (or visit /dashboard?yc=1)
4. Watch:
   • Bottleneck card highlights "PR review time up 42%"
   • Agent timeline streams: detect → analyze → plan → act → verify
   • Long-pole PR (#202) gets a new backup reviewer (Noor)
   • Slack mock messages appear in #engineering
   • Health score animates 62 → 87, avg PR wait 31h → 11h
5. Visit /workflows — see the four pre-built loops
6. Visit /agents — see the live audit timeline streaming in

---

Project structure

throughloop/
├── app/
│   ├── layout.tsx                      # root layout + fonts
│   ├── globals.css                     # tailwind + custom utilities
│   ├── page.tsx                        # landing page
│   ├── dashboard/page.tsx              # main demo (YC mode autoplay)
│   ├── workflows/page.tsx              # 4 pre-built workflows
│   ├── agents/page.tsx                 # live agent activity timeline
│   └── api/
│       ├── demo-data/route.ts          # GET — engineers, PRs, tickets, slack
│       ├── analyze/route.ts            # POST — runs analyzeEngineeringExecution()
│       ├── execute-fix/route.ts        # POST — runs executeFix()
│       └── agent-logs/route.ts         # GET — initial timeline
├── components/
│   ├── ActionButton.tsx
│   ├── AgentTimeline.tsx
│   ├── BottleneckCard.tsx
│   ├── Card.tsx
│   ├── EngineerChip.tsx
│   ├── ExecutionLog.tsx
│   ├── HealthScore.tsx
│   ├── Logo.tsx
│   ├── MetricCard.tsx
│   ├── Nav.tsx
│   ├── PRRow.tsx
│   ├── SectionHeader.tsx
│   ├── Sparkline.tsx
│   ├── StatusBadge.tsx
│   └── WorkflowCard.tsx
├── lib/
│   ├── types.ts                        # all domain types
│   ├── mock-data.ts                    # engineers, PRs, tickets, slack, workflows
│   ├── ai-engine.ts                    # analyzeEngineeringExecution()
│   ├── execution-engine.ts             # executeFix() + safety policy
│   └── utils.ts
├── tailwind.config.ts
├── postcss.config.js
├── next.config.js
├── tsconfig.json
└── package.json

---

Running locally

cd throughloop
npm install
npm run dev
# open http://localhost:3000

Build & start:

npm run build
npm start

Requires Node 18.17+ (tested on Node 20).

---

How the AI engine is structured

lib/ai-engine.ts exports a single function:

analyzeEngineeringExecution(ctx) → {
  bottlenecks,
  rootCauses,
  recommendedActions,
  executionPlan,
  confidenceScore,
  riskLevel,
}

It is deterministic and mock-first — same shape a real Claude/OpenAI call would return. Swap the implementation later; the UI doesn't change.

Heuristics in v0:

• PR waiting > 24h → flag bottleneck
• Reviewer with > 3 pending PRs → mark overloaded
• Highest-priority + longest-waiting PR → flag as long pole
• Pick a backup reviewer who is available and below the overload threshold
• Blocked junior engineer → escalate

lib/execution-engine.ts exports executeFix(plan) that simulates each action, respects guardrails, and returns logs.

Safety guardrails

Built in, not bolted on:

• ❌ Never merges code
• ❌ Never deletes tickets
• ❌ Never messages customers
• ✅ External Slack messages require human approval
• ✅ Internal engineering notifications can auto-approve
• ✅ Every action is logged with a timestamp

---

Future integrations

The mock layer is structured to drop into real APIs:

• GitHub (review assignment, PR state)
• Linear / Jira (ticket update + sprint state)
• Slack (notifications, DMs, threads)
• Notion (postmortem doc generation)
• Google Calendar (auto-schedule sync if drift > 2σ)

The dependency surface is intentionally small — each integration is a single adapter behind the same executeFix signature.

---

YC application positioning

What are you building? Throughloop is the AI execution layer for engineering teams. We detect shipping bottlenecks the moment they appear and execute fixes — reassign reviewers, update tickets, notify the right person — with guardrails. It's not a chatbot or a dashboard; it's the agent that closes the loop between "something went wrong" and "it's fixed."

Who needs this? Eng leaders at 20–500-person startups whose teams are leaking shipping velocity to invisible coordination work. The EM running 6 squads, the technical co-founder watching scope creep wreck a sprint, the head of eng who keeps hearing "PR was waiting on review" in standup.

Why now? Three things converged: (1) LLMs are finally good enough to reason over real PR/ticket/Slack context, (2) eng tools (GitHub, Linear, Slack) are now fully API-first, and (3) eng teams are post-ZIRP — every percent of velocity matters. Dashboards had a decade. The next decade is execution.

What makes it different? Three things: narrow, opinionated, and acts. Most "AI for eng" products surface signals — we close loops. Copilots write code; we make the team around the code work. We ship one workflow at a time, not a platform. And every action has a reversible audit trail by default — this is a load-bearing trust property, not a setting.

---

Demo script (3 minutes)

"Eng teams leak shipping velocity in dozens of small coordination failures. PR review takes 3 days. A junior is blocked silently. Sprint scope creeps. Today you find out about it in standup. By then it's too late.

Throughloop watches the same signals your team already produces — PRs, tickets, Slack — and acts the moment drift appears. Watch."

(click Run YC demo)

Health score: 62. PR review time up 42%. Throughloop flags it before standup. It identifies that 2 senior reviewers are overloaded and PR #202 is the long pole. It reassigns to Noor, posts to #engineering with context, updates the Linear ticket. Health score climbs to 87 in real time.

"Detect → act → verify → improve. That's the loop. We ship one workflow today; three more queued. Eng leaders give us read-only access; in two weeks they're letting us act. The product is the retention story."

---

Status

This is a YC application MVP. All data is mock. Real integrations are next.