Source control

See what changed, and why

Aura grafts onto the Git you already use and reads changes at the logic level: not just the red and green lines, but the meaning underneath them, with the reason an agent made each change captured on every commit.

Logic-level semantic diffA reason on every commitAST-anchored PR review
Compare Aura
Source Control: acme-api
1 file+8 −6
Msrc/retry.rs+8 −6
ChangeRetries now wait longer after each failure instead of pausing the same half-second every time, so a rate-limited service gets progressively more room to recover. · net: exponential backoff for retries
Previous was this
  • ~
    Retry With Backoffchanged
    Why: Each retry now sleeps for the delay compute_delay returns instead of a flat 500 ms, and takes the operation by FnMut so callers can retry stateful closures.
    retry_with_backofffn
  • −
    Sleep Fixedremoved
    Why: Removed: the constant half-second sleep is replaced by the exponential compute_delay path.
    sleep_fixedfn
New is this
  • ~
    Retry With Backoffchanged
    Why: Each retry now sleeps for the delay compute_delay returns instead of a flat 500 ms, and takes the operation by FnMut so callers can retry stateful closures.
    retry_with_backofffnpub fn retry_with_backoff<T, E>(max_attempts: u32, mut op: impl FnMut() -> Result<T, E>) -> Result<T, E>
  • +
    Compute Delayadded
    Why: New helper that grows the backoff window: starts at 100 ms and doubles after every failed attempt.
    compute_delayfnfn compute_delay(attempt: u32) -> Duration
@@ -1,20 +1,21 @@
1 use std::thread;1 use std::thread;
2 use std::time::Duration;2 use std::time::Duration;
3 3
4-const FIXED_DELAY_MS: u64 = 500;4+const BASE_DELAY_MS: u64 = 100;
5 5
6 /// Retry `op` until it succeeds or `max_attempts` is reached.6 /// Retry `op` until it succeeds or `max_attempts` is reached.
7-pub fn retry_with_backoff<T, E>(max_attempts: u32, op: impl Fn() -> Result<T, E>) -> Result<T, E> {7+pub fn retry_with_backoff<T, E>(max_attempts: u32, mut op: impl FnMut() -> Result<T, E>) -> Result<T, E> {
8 let mut attempt = 0;8 let mut attempt = 0;
9 loop {9 loop {
10 match op() {10 match op() {
11 Ok(value) => return Ok(value),11 Ok(value) => return Ok(value),
12 Err(err) => {12 Err(err) => {
13 attempt += 1;13 attempt += 1;
14 if attempt >= max_attempts {14 if attempt >= max_attempts {
15 return Err(err);15 return Err(err);
16 }16 }
17- sleep_fixed();17+ thread::sleep(compute_delay(attempt));
18 }18 }
19 }19 }
20 }20 }
21 }21 }
@@ -23,8 +24,10 @@ pub fn retry_with_backoff<T, E>(max_attempts: u32, op: impl Fn() -> Result<T, E>)
23 }24 }
24 }25 }
25 26
26-/// Sleep a constant amount between attempts.27+/// Exponential backoff: the wait doubles after every failed attempt.
27-fn sleep_fixed() {28+fn compute_delay(attempt: u32) -> Duration {
28- thread::sleep(Duration::from_millis(FIXED_DELAY_MS));29+ let factor = 1u64 << (attempt - 1);
30+ Duration::from_millis(BASE_DELAY_MS * factor)
31+}
01

Meaning, not red-and-green

Hover any function to read what it does in plain language, and watch that meaning when an agent touches it, so a quiet behavioral change can never sneak through.

Semantic review
Reworked 3 functions (retry with backoff, compute delay, sleep fixed).
Used to
Every retry waited the same flat half-second, so a service that was already rate-limiting us kept getting hit at a fixed pace.
Now
Retries now wait a delay that doubles each attempt (100 ms, then 200, 400, 800…) capped at 30 seconds, so a struggling endpoint gets progressively more room to recover.

Why & how · A flat delay ignores how overloaded the other side is. Exponential backoff is the standard way to behave under rate limits, and the cap keeps the wait from growing without bound.

src/retry.rs
Previous was this
  • ~
    Retry With Backoffchanged
    This function was reworked.
    Why: Each retry now sleeps for an exponential delay instead of a flat 500 ms, and takes the operation by FnMut so callers can retry stateful closures.
    retry_with_backofffn
  • −
    Sleep Fixedremoved
    This function was removed.
    Why: Removed: the constant half-second sleep is replaced by the exponential compute_delay path.
    sleep_fixedfn
New is this
  • ~
    Retry With Backoffchanged
    This function was reworked.
    Why: Each retry now sleeps for an exponential delay instead of a flat 500 ms, and takes the operation by FnMut so callers can retry stateful closures.
    retry_with_backofffn
  • +
    Compute Delayadded
    A new function.
    Why: New helper that computes the backoff window: base 100 ms doubled per attempt, capped at 30 s so the wait can never run away.
    compute_delayfn
Proven · 3/3 checkschecked against the goal, and it passed
02

A reason on every commit

Each commit carries the intent behind it, checked against what actually changed. If the words and the code disagree, Aura flags it before it lands.

Session review

Make network retries back off exponentially instead of pausing a flat 500 ms every time: cap the wait at 30 s so a rate-limited service gets progressively more room to recover.

Claude Code·2h·3 turns·1 file+8 / −6·refactor·Signed

The AI changed 3 things across 1 file.

Worth a look: 1 deletion. Nothing else here looks risky.

Asked

Claude Codeprompt2h

Make network retries back off exponentially instead of pausing a flat 500 ms every time: cap the wait at 30 s so a rate-limited service gets

Saidwhat the agent logged

Claude Coderefactor2h

Make network retries back off exponentially instead of pausing a flat 500 ms every time: cap the wait at 30 s so a rate-limited service gets progressively more room to recover.

What changed

3 changes·1 file
ƒsleep_fixeddeleted
src/retry.rs

Replaced by the exponential compute_delay path.

ƒretry_with_backoffmodified
src/retry.rs:8

Each retry now waits the delay compute_delay returns instead of a flat 500 ms, and takes the op by FnMut so stateful closures can be retried.

ƒcompute_delayadded
src/retry.rs:28

New helper: starts at 100 ms and doubles after every failed attempt.

Time machine puts one part of this change back the way it was, just that part, nothing else. Aura keeps a copy of every file from before the AI touched it, so you can always undo.

03

Pull requests with a purpose

Open a PR with an automated safety check, a test plan, and review comments anchored to the logic, not to line numbers that drift on the next edit.

Pull request
tasks #128

Add task priorities to the app

featurepriorities
Mmhask
feat/task-priorities→add-priority-field3 files+83−7Updated 28d ago
main(trunk)
Description

Every task now carries a priority (low, medium or high) so the most important work floats to the top of the board.

Older tasks default to medium, so nothing is left blank and the highest priorities are obvious at a glance.

  • P
    Priya29d ago

    Love this: the little colour tag makes priority obvious at a glance.

  • M
    Mo28d ago

    One thought: can we default older tasks to medium, so nothing looks urgent by mistake?

Files changed3+83−7
  • src/model/task.rs+24−2
  • src/board/sort.rs+18−5
  • src/ui/PriorityBadge.tsx+41
More of the platform
Mission Control
Every agent, task and PR in one window
Crew
The autonomous work-loop that ships proven fixes
Trace & proof
Every change tied to the goal it delivered
Memory
Recall an agent can query before it edits
Team radar
A live awareness plane so agents never collide
Cloud machine
Hand a job to an always-on machine, get the result back

Ship with proof, not hope

Free public beta for macOS and Linux. Point it at a repo and drive every agent you already use.