Skip to content
gitgot

From repo URL to first-pass PR.

Paste any public GitHub repo. Map the architecture, surface real owners, classify the open issues, and draft a PR against the one you choose.

Sign in with GitHub to open requests. Sign in

· how it works

Five steps from URL to PR.

Each step runs in your browser. Analysis streams as it completes, the agent works in a sandbox you can watch, and the PR lands on GitHub as a draft.

· 01 · one input

Paste a GitHub URL.

Any public repo. gitgot accepts the full URL or the owner/repo shorthand.

01 · paste url

· gitgot · new analysis

github.com/honojs/hono
· public · 18.4k stars · TypeScript
· last commit: a73f1c · 6h ago
· 168 open issues · 12 contributors active

· 02 · live analysis

Watch the analysis stream in.

Workspace detection, import graph, layer attribution, owner inference from git history, and issue classification run in a single pass. Each step posts to your browser as it finishes.

02 · live analysis

· streaming analysis · honojs/hono

✓ cloned @ a73f1c
✓ detected 4 workspace packages
✓ built import graph · 412 modules
✓ inferred 23 code owners
✓ classified 168 issues
● writing overview
elapsed00:47

· 03 · classified backlog

Pick an issue.

Every open issue arrives tagged with a category, a complexity, a confidence score, and the files it likely touches. Skim the backlog in minutes instead of an hour.

03 · classified backlog

· 168 issues · pre-classified

#4291Add streaming to c.json() for large payloads
featureeasy
#4287JWT middleware drops claims on refresh
bugmedium
#4279Document custom Context.var typing
docseasy
#4264Refactor router benchmark suite
choremedium

· 04 · agent in a sandbox

Agent works in a sandbox.

A fresh container clones the repo, branches off main, and runs the agent. A browser shell on the request page shows the work in real time.

04 · sandbox

· agent · #4291 · streaming json

$ git checkout -b gitgot/issue-4291
$ open src/context.ts
→ reading existing jsonStream implementation
→ rewriting using ReadableStream
→ adding test/streaming.spec.ts
✓ vitest · 184/184 pass
✓ tsc · clean
✓ eslint · clean
turns8·elapsed02:11

· 05 · draft pr, your call

Review the draft PR.

The PR opens on GitHub as a draft with the prompt the agent used. Comment on the request page or on GitHub to send feedback back to the agent. You decide what merges.

05 · draft pr · #4302

· draft pr opened

feat(context): stream large json payloads via ReadableStream

draftlint · passtsc · cleantests · 184/184
+ 47− 122 files
src/context.ts · +29 −12
test/streaming.spec.ts · +18 −0

Your turn. Comment, pull the branch, or merge.

· what you get

What you get from one run.

Four artifacts, all kept against your account so a second visit to the same repo is instant.

· architecture map

Layered architecture map of the codebase.

Workspace detection, import-graph traversal, and layer attribution (entry, core, extension, shared, infra) run deterministically first. A single LLM pass then enriches each component with a description and a pattern summary.

  • Workspaces auto-detected for pnpm, yarn, npm, and turborepo.
  • Re-runs reuse the prior result if the repo SHA matches, so the second visit lands in seconds.
architecture · honojs/hono

· 5 components · 412 modules

src/router
entry4 deps
src/hono
core9 deps
src/middleware
extension6 deps
src/adapter
infra3 deps
src/utils
shared12 deps

· code owners

Real owners, inferred from git history.

A clustering pass over git blame with bot filtering and decayed-recency scoring surfaces who actually maintains each part of the repo. Name aliasing across different emails and historical name changes is handled, so the top contributors are real people.

  • Per-file and per-feature owner lists with confidence scores.
  • Bus-factor warnings for code with one effective maintainer.
  • CODEOWNERS respected when present, merged into the result rather than replaced.
ownership · src/router

· 4 owners · 0 bus-factor flags

yusukebe
142 files·3d
dadaiwen
48 files·1w
asecondskoolband
31 files·2w
sokra
19 files·6w

· issue classification

Every open issue pre-classified.

A parallelized LLM pass reads each open issue alongside the architecture and feature context, and tags it with a category, a complexity, a confidence score, and the files it likely touches. Triage becomes a twenty-minute async read.

  • Categories cover bug, feature, chore, docs, and unclear.
  • Easy, medium, and hard complexity with reasoning attached.
classification · 168 issues

· distribution

bug
34%
feature
29%
chore
21%
docs
12%
unclear
4%
easy + high confidence → 42 ready for agent

· draft pr + context prompt

Draft PR plus the prompt that drove it.

When the agent finishes, a draft PR opens on GitHub with the diff, the verification log, and the prompt it used. Pull the branch into Cursor or Claude Code, paste the prompt, and your local agent has full context on the issue, the architecture, the ownership, and the files touched.

  • Sandbox stays warm so iteration does not re-provision.
  • PR body links back to the request page for the full verification log.
  • Reproducible prompt: same inputs build the same context.
draft pr · #4302 + context prompt

· prompt for your local agent

## task

Continue PR #4302 on honojs/hono.

## context

Issue #4291 · streaming json · feature · easy

Files: src/context.ts, test/streaming.spec.ts

Owner of src/context: yusukebe (3d)

## architecture

src/context is in core layer; touched by 47 modules.

$ gh pr checkout 4302copy →

· trust

Trust and limits.

How gitgot keeps you in control of what ships.

· the objection

"Will the agent merge code without me?"

· the answer

Humans decide what merges. Always.

Every PR opens as a draft. The agent never auto-merges, never pushes to main, never closes an issue on its own. You review the diff, finish the work in your editor, and merge when the PR is ready.

  • Draft PR only, never auto-merged.
  • Per-user concurrent-request limits, default of three.

· the objection

"What happens to my code?"

· the answer

Cloned per request, discarded on close.

Each request runs in a fresh sandbox; the repo is cloned there and destroyed when the request closes. Only the analysis itself (architecture map, owner inferences, classifications) is kept against your account, so a second visit to the same repo is instant.

  • Per-request sandbox, destroyed when the request closes.
  • No model training on your code, no shared embeddings.

· the objection

"How do you keep the PR from being garbage?"

· the answer

Verification gates the PR before review.

Lint, typecheck, and the project's test suite run in the sandbox after the agent commits. Only a passing or self-retried build leaves draft, and the verification log lives on the request page for every commit. The diff is a starting point you finish in your editor.

  • Lint, typecheck, and tests run inside the sandbox.
  • Failing builds keep the PR in draft and trigger one self-retry.
  • Verification log attached to each commit.

· what's next

What's next.

Today gitgot is a focused tool for open-source contribution. Three threads of work are next.

Private repos and team channels.

Private GitHub repos, plus Linear and Slack as additional sources for the issues you triage and pick up.

Onboarding new hires to any codebase.

Use the same architecture and feature maps to ramp engineers and technical support staff into a codebase on their first day.

Role handoffs.

Engineering, DevOps, and product handoffs that carry codebase context end to end, without writing a fresh doc each time.

· common questions

Common questions.

If something is missing, the contact link in the footer reaches a real person.

· try gitgot

Pick a repo you want to contribute to.

No installs, no setup. Paste the URL and the analysis streams in. Sign in with GitHub when you are ready to open a request.

Need a tour first? See how it works