URSA Dev

One model handles implementation. Another reviews. Local models take routine work. Stronger models handle the work that actually needs them.

You decide which models get used where, when the system switches and what happens if the preferred model isn't available.

One model plans. Another builds. Another challenges the work. Another tests it.

Those roles stay in the development setup instead of being recreated every time.

Another model reviews the change, tests pass, you approve it or the workflow requires some combination of the three.

The model that did the work doesn't automatically get to declare its own work finished.

A UI adjustment moves through normally. A change touching authentication, architecture or sensitive data automatically brings in another reviewer, stronger verification or a human approval step.

You decide what counts as higher risk and what happens when the system sees it.

Models inspect, write and test within the boundaries you set. Deployment, destructive operations or major architecture changes stop for approval when that's the rule.

The boundary stays in the development process instead of depending on you remembering it in the moment.

Coding conventions, architecture decisions, naming rules, approved dependencies, protected areas and things the models simply aren't allowed to do stay with the project.

You don't have to repeat the same rules every time a new session starts.

Projects have history. Decisions were made. Things were tried. Some worked. Some didn't. Requirements changed. Certain areas became off-limits.

URSA Dev keeps that history available so every new session doesn't start by trying to reconstruct the project from scratch.

Set the files, folders, branches, worktrees, repos or types of changes that belong inside the task.

A documentation job doesn't need authority over the whole application. A small repair doesn't need access to everything either.

Tests, builds, runtime checks, diffs, repository state and whatever else the project depends on become part of completion.

The model saying something worked isn't the same thing as establishing that it worked.

Routine inspection, repetitive work and lower-risk jobs go to local, free or cheaper models when they're sufficient. Hard architecture, debugging or adversarial review goes somewhere stronger.

You decide where the money is worth spending.

Use Claude today, Codex tomorrow and local models for routine work.

The project's rules, review process, verification and history don't disappear because the model changed.

Go back to a known state, keep the evidence from what failed and decide how to approach it again.

Use another model or another strategy when that makes sense. Don't blindly patch the patch until nobody knows what state the repo is in.

Security, architecture, testing, documentation, adversarial review or another role specific to the project stays available as part of the environment.

Work that always needs the same kind of scrutiny automatically gets the right reviewer.

A bug fix, a refactor, a deployment and a production emergency don't need the same workflow.

Set up each process once, then reuse it when that kind of work comes up again.

Separate worktrees, repos, responsibilities and integration points keep parallel work from turning into one shared mess.

You get the speed of parallel development without pretending that all of those lanes are the same state.

When several models work quickly, it gets hard to remember what was proposed, what changed, what got reviewed, what passed and what actually reached the repo.

URSA Dev keeps those states separate so the record doesn't depend on somebody remembering the conversation later.

Cloud-eligible work goes to cloud models. Local-only code, files or project information stays on the machine.

Those rules stay in the development setup instead of being decided ad hoc every time.

A developer works directly in the terminal and repo. Someone less technical uses a guided interface.

The review, scope, verification and approval rules underneath stay the same.