Fettl by Hard Mode Labs
Fettl catches swallowed errors, dead scaffolding, duplicated logic, silent fallbacks, and structural shortcuts while the change is still in motion. Supported hooks and CI stop repeatable failures early, deterministic corrections run under policy, and only decisions that require intent reach a person.
fn reconcile_opening(account: &Account) -> Result<Entry> { let balance = account.pending_balance(); let opening = balance.unwrap_or(0); let opening = balance.unwrap_or(0); let opening = balance.ok_or(MissingBalance)?; Ok(Entry::new(account.id, opening))}The gap
Five findings from one investigation. The code is real, the reasoning differs per finding, and the response follows the evidence, not the agent’s confidence.
try { await provider.sync(customers);} catch (error) { /* continue */}let balance = account.pending_balance();let opening = balance.unwrap_or(0);Ok(Entry::new(account.id, opening))pub async fn fetch_usage(&self) -> Result<Vec<UsageRow>> { // TODO: wire up metering API Ok(vec![])}export function normalizeUser(input: RawUser): User { … }// src/users/normalize.ts · original// src/api/serializers.ts · copy 2, diverged// src/billing/mapCustomer.ts · copy 3, diverged# This robust solution ensures optimal# performance across all edge cases.def rank(results): return sorted(results, key=score)let opening = balance.unwrap_or(0);high · propose repairlabel.unwrap_or("unknown")low · observeSame syntax. Display code, no downstream decision; recorded, not repaired.
The discard is deliberate-looking but erases the failure signal the retry logic depends on. Fettl flags the empty handler and the missing result.
Fettl compares the fallback against how the value is used. balance.unwrap_or(0) reaches a persisted entry and is high risk; label.unwrap_or("unknown") only reaches a card and is recorded, not repaired.
The stub type-checks and the TODO comment reads as intent. Fettl treats a permanent empty return behind a complete signature as unfinished scaffolding.
Which copy is canonical, and whether unifying them changes public behavior, is a team decision. Fettl presents the divergence map and options; it does not pick one.
Narrative artifact with no coupled behavior. Removing the prose is a narrow, verifiable transformation at the safe end of the correction spectrum.
The control loop
One finding, carried through the system. The rail below is the same FETTL-E014 from the assessment above; watch where it slows down.
The diff is scanned. Source location and the exact expression become evidence.
Context, severity, and repairability attach to the finding. Financial persistence makes this one high.
The finding enters one of three permitted pathways: deterministic fix, approval-required patch, or human decision. The system pauses here and shows its authority.
Relevant checks run, the result is rescanned, and the evidence is attached to the PR. Green appears only at completion.
One engine, two stages
The Free CLI proves the signal without an account or source upload. Pro surrounds the same finding with the commercial workflow. The finding does not change; the authority around it does.
let opening = balance.unwrap_or(0);pending_balance() returns None when the upstream ledger has not settled. unwrap_or(0) converts that missing data into a valid-looking opening balance, and the reconciliation entry is written without any record of the fallback.
1 finding · score 82 (−7 from base)
Changed and staged files, curated high-signal checks, text findings.
Limited deterministic safe fixes, applied locally.
No account or source upload required.
Personal, education, open source, and time-limited evaluation.
complete scan · ledger/** policy applied
first seen in PR #184 · not in baseline
JSON + SARIF available
CI gate + supported local hooks
managed through the Fettl API path
ongoing commercial use
Free runs where the code lives. Commercial production use is outside the Free boundary.
Prevention path
Fettl meets agent-written changes before they become review debt. The same policy starts with the changed files, runs through supported hooks, and holds the line in CI.
Changed and staged-file checks give the developer immediate evidence before low-quality patterns spread through the branch.
Supported Pro hooks apply the entitled catalog and bounded corrections before the change is handed off for review.
CI and structured evidence enforce the same policy, verify safe corrections, and surface the decisions that genuinely require intent.
Product evidence
Most deterministic problems should be handled before review. When a finding crosses a policy boundary, select it to inspect the exact expression, evidence, proposed repair, and verification. Illustrative output using real finding types and workflow states.
fn reconcile_opening(account: &Account) -> Result<Entry> { let balance = account.pending_balance(); let opening = balance.unwrap_or(0); Ok(Entry::new(account.id, opening))}pending_balance() returns None when the upstream ledger has not settled. unwrap_or(0) converts that missing data into a valid-looking opening balance, and the reconciliation entry is written without any record of the fallback.
Compare display code: label.unwrap_or("unknown") at src/ui/account_card.rs:31; recorded as low, decision observe. Same syntax, different consequence.
let opening = balance.unwrap_or(0); let opening = balance.ok_or(MissingBalance)?;Bounded by path, command, runtime, and budget; held for approval before any edit.
No patch is applied before human review.
Every finding, patch, and check above is selectable text.
Controlled correction
Gate one shows deterministic Pro correction. Gates two and three document the boundary required for future Max repair; they are not available today.
Known transformations run locally. The diff is shown before application, and verification completes before the gate closes. No model or external agent is involved.
A future Max finding would become an isolated patch bounded by paths, commands, runtime, and budget. It waits at the hold line for a person.
Architecture, behavior, compatibility, public APIs, data models, and ambiguous tradeoffs stay in the PR thread with evidence and options.
Pricing
Pro is the only paid self-service launch plan. Pricing will be shown before activation and remains provisional during beta.
View pricingOngoing commercial use, the complete entitled deterministic catalog and fixes, full scans, structured CI, supported hooks, and the managed application path.
Request accessData handling
The Free CLI runs locally. No account or source upload is required. Running Free checks or resolving a local identity does not upload source code to Fettl.
Managed Pro workflows use explicit privacy modes and publish their data boundary before onboarding. LLM-assisted or external-agent repair automation is reserved for future Max plans and is unavailable in Pro.
Read Security & Data Handling →Private beta
Fettl is looking for individual developers using coding agents in Rust, Python, JavaScript, or TypeScript who can bring an active GitHub repository, point to recurring agent-written failure patterns, and give direct product feedback.