Start the draft
Start from a prompt, a GitHub issue, or a repository todo. Point ProPR at the repository and attach screenshots of the bug or feature.
Plan the work before the agent writes the code.
If you throw a prompt at an agent, it guesses. ProPR forces a planning step first. You see the exact context it gathered, fix its assumptions, and shape the architecture before you spend implementation tokens or wait for code. Measure twice, cut once.
Prompt
GitHub Issue
Repo To-Do
Context Gathering
Repo Index
Screenshots/Files
Preview Cost & Tokens
Refine & Chat
Approved PlanLinked GitHub Issues
Product path overview
Treat planning like a --dry-run for your agent.
ProPR has the agent write a spec before it edits files and opens a messy PR. You define the change, handpick context files, and set the acceptance criteria. If the approach is wrong, fix it here while edits are still cheap.
Once approved, the plan becomes the working specification for implementation, review, and follow-up.
Follow a plan from request to merge.
This public setup-wizard change shows context gathering, plan generation, refinement, issue creation, isolated implementation, a GitHub follow-up, review, and the final human merge.
Catch architectural flaws before they become commits.
The public setup-wizard example keeps its repository, branch, requirements, acceptance criteria, and chat history visible before any agent run begins.
From an idea to execution in four steps.
Asking an LLM for a plan is the easy part. Validating its assumptions is the hard part. ProPR keeps you in control:
Preview the context
Before you spend an API token, ProPR shows which files it will send to the planning model. Check the token count, verify the scope, and catch missing context early.
Generate and refine
The agent drafts a structured plan. Ask it to split broad tasks, cover missed edge cases, or add tests. Work through the architecture before it touches the codebase.
Finalize and start
When the plan looks solid, ProPR creates the GitHub issues. Pick the agents and models, start the runs, and let the isolated execution loop take over.
Context starts before you even type.
An agent is only as good as its understanding of your codebase. ProPR continuously indexes your repository, so when you ask for a new feature, the planner already knows your file structure, existing patterns, and dependencies.
Repository indexing
ProPR reads the repository, tracks branches, and prepares searchable knowledge so the planner finds relevant files without making you point out each one.
Summaries and browse
You inspect repository summaries, browse files, and chat against repository knowledge before turning an idea into a plan.
New repository plans
ProPR plans and implements empty repositories from scratch, using supporting repositories as reference material when the new project should follow existing patterns.
Improvement signals
The same repository understanding produces improvement suggestions or todos that later become planned changes.
Show the model what matters.
Missing context leads to bad implementations. Before the agent drafts a plan, ProPR shows you exactly which files it intends to read. You can manually include missing dependencies or exclude noise, ensuring the agent actually understands your architecture before it goes down the wrong path.
The first plan is just a starting point.
ProPR turns your prompt into a proposed execution plan: scope, task boundaries, and risks. Scrap it when the premise is wrong. If it is close, open the chat and refine it.
Generated task breakdown
ProPR slices a large feature request into smaller tasks ready for focused review.Draft validation
ProPR repairs malformed model output and enforces the task boundaries you selected.Refinement chat
Ask for a simpler plan, different boundaries, more tests, or a completely different architectural approach.
Code starts when the plan is solid.
Approval is the handoff. Once you greenlight the plan, ProPR translates it into actionable GitHub issues, assigns the models, and triggers the isolated execution loop.
One focused task
Use this for a clear, isolated change that reviews as a single diff.
Several tasks ready for review
Use this when a broad prompt needs separate issues and separate PRs.
Epic mode (sequential PRs)
Use this for a large feature with tasks that build on each other. ProPR creates a shared Epic PR, runs the planned issues one at a time, and auto-merges each green child PR into the Epic branch before starting the next. The final Epic PR presents the full feature for review.
Keep refining in the PR
After the PRs open, participants keep refining the code by leaving normal GitHub comments through PR fine-tuning.
Epic mode pipeline
Approved PlanLarge prompt split
Issue 1Merged
Issue 2Auto-merging...
Feature DeliveredReady for review