Every change starts from repository knowledge.

ProPR indexes each repository, summarises its structure, and plans every change from that map. It works the same on a mature codebase that has to keep shipping and on an empty repository that needs its first pull request.

The courier app's repository workspace on the Improve tab: Performance and UX & UI themes, custom instructions, and two of the generated suggestions selected — Generated improvement ideas inside the repository workspace.

The codebase is mapped before a task exists.

Indexing runs on your host with the agent you already configured. ProPR tracks branches and writes summaries you can read, so every plan starts from the current shape of the code.

Indexed repositories with the commit each index was built from and when; Platform infra re-indexing at 64% — Every index names the commit it was built from. Platform infra is re-indexing after a large merge.

Repository chat on the courier app: asked what happens to a delivery photo offline, it names photoStore.ts, uploadQueue.ts and the retry policy, and notes the queue stops when the app is suspended

Browse and chat with the summaries

Ask the repository how something works before you decide an idea is worth building. Answers name the files they found.

Included Context (8 files): the courier-app files the planner will read, ranked by relevance, led by uploadQueue.ts and ProofOfDelivery.tsx

Planning starts from the map

The index ranks the files for each prompt. Context gathering shows the selection and lets you adjust it before the planner reads a line.

Two indexed repositories, orders-api and storefront-web, added to a plan as reference context: read for patterns, while all implementation stays in the target repository

Reference repositories join a plan

Pull a service, client or shared library into a plan as read-only reference, or point a new repository at the patterns it should follow.

A plan request with a screenshot of the failed upload attached for the planner

Empty repositories start from your material

The plan starts from your prompt, screenshots, attachments and reference repositories, and returns as the repository's first pull request.

Mature codebases have conventions. The plan follows them.

In a product that is already shipping, generating code is easy. Finding the right files, respecting local patterns and keeping the change reviewable is the work, and ProPR starts it from the index.

A generated plan broken into five ordered tasks, each a future GitHub issue

Changes arrive in reviewable pieces

Planning splits larger ideas into focused tasks, each reviewable as one diff.

One pull request’s runs: review scored 5, a fix, review scored 7, and the Ultrafix cycle in progress

Review is part of the change

A change is ready when the pull request survives comments, checks and human judgment. Every iteration runs on the PR through PR fine-tuning.

The undo link’s preview: the merge commit becomes the new head and the follow-up commit after it is removed

Recovery is obvious

When an attempt is wrong, the task record and completion comments show what happened. Retry, discard or revert it.

A focused real GitHub pull request built by ProPR, showing its implementation summary, branch, commit, model, duration, tokens, and cost. — The destination: a normal GitHub pull request carrying its execution record.

Turn what it finds into planned work.

Improvement suggestions

Repository analysis suggests follow-up changes. Save the ones you like as todos, or open a plan draft from selected improvements.

Repo todos

Categorized todos are the second path: pick and order items, then turn them into a plan draft from todos.

The courier app's to-dos: a search box and two categories, Offline mode and Driver experience, each with its own items — The courier app's backlog, sorted into categories.

Start from a prompt, issue, todo, improvement or empty repo.

All of them become planned changes, and planning shapes the scope before implementation starts.

Keep the final decision in the pull request.

The branch, diff, checks, comments and merge decision live in GitHub. The app-builder comparison shows how that differs from a hosted prototype.