Slope

Ship your first PR faster

Comment

Inspiration

Getting assigned a GitHub issue on a large or unfamiliar repo still means a lot of guessing: which files matter, what could break, and how pieces connect. Tickets often include screenshots or diagrams, but that visual context is easy to lose when you are digging through the tree alone. We wanted assignment to be the moment the repo meets you halfway — so you can ship your first change faster instead of burning hours on orientation.

What it does

Slope listens for a GitHub webhook the moment an issue is assigned. It reads the ticket — including any screenshots or diagrams embedded in the body — using Gemini's multimodal understanding, then runs an Augment Code agent over a real clone of the repository to identify the most relevant files with verified, code-grounded reasons. It recalls lessons from past runs on the same repo, then produces an onboarding map: a prioritized reading list, warnings, and a Mermaid dependency graph. Zero human steps: the issue gets a comment and a link to the dashboard automatically.

How we built it

  • Backend: FastAPI handles webhook signature verification, idempotency (so duplicate GitHub deliveries never spam an issue thread), and async pipeline orchestration across seven sequential steps.
  • Augment Code: For each run, Auggie shallow-clones the repository and acts as a full coding agent — reading real source files to rank relevant paths and surface dependency notes. This is what keeps the map grounded instead of generic.
  • Gemini: Multimodal ticket analysis (text + images) feeds into structured ticket classification and the final onboarding map generation.
  • Railtracks: The pipeline runs as a traced Railtracks flow, giving step-by-step observability you can watch live with railtracks viz.
  • Frontend: Next.js dashboard — run list, run detail with the markdown issue body, image strip, memory snippets, and rendered Mermaid graph.

Challenges we ran into

  • Latency and reliability: Steps like repo clone, Augment agent execution, and LLM calls can be slow or fail independently; we needed clear per-step logging, graceful skips, and fallbacks so a partial failure does not look like a silent no-op.
  • Idempotency: GitHub can redeliver webhook events; we detect an existing marker comment before re-running so a retry never spams the issue thread.
  • Composing tool outputs: Augment's file rankings, Gemini's ticket analysis, and recalled memory snippets all feed the final map prompt — getting the right signal from each without overloading context took real iteration.

Accomplishments that we're proud of

  • True end-to-end autonomy: a GitHub assignment triggers seven pipeline steps and posts a useful artifact — map, dependency graph, dashboard link — with no human in the loop.
  • Multimodal issue understanding: Gemini reads screenshots and diagrams from the issue body as first-class inputs, not an afterthought.
  • Compounding team memory: each successful run distills warnings, risk surface, and key paths into a lesson stored per repo. Future runs on related areas surface those lessons automatically, so the map gets richer over time.
  • Full Railtracks observability wired into the same pipeline that runs in production.

What we learned

  • GitHub integrations are easier said than done
  • Augment's ability to read actual code in a cloned workspace is actually really really good

What's next for Slope

  • GitHub App installation instead of long-lived PATs, tighter scopes, and org-wide rollout.
  • Richer memory with embedding search and opt-in retention policies, plus optional human approval before posting issue comments.
  • PR-aware maps when a branch or draft PR is linked from the issue.
  • Surface Augment and analysis evidence directly on the run page so every file suggestion is easy to audit.

Built With

Share this project:

Updates