Fix real broken systems with AI — before anything runs
Turn bugs into safe, explainable changes.
See what would happen before you apply a fix.
Fork this repo. Pick a broken scenario. Let Xable inspect it, simulate a safe fix, and explain what would change before anything runs.
This is a playground of intentionally broken systems.
Instead of blindly fixing code, the goal is different:
- propose a change
- simulate the outcome
- understand the impact
- decide what to do
You don’t just fix bugs.
You see what would happen first.
npm install
npm test
# Run a specific beginner scenario
npm run scenario:react
npm run scenario:api
npm run scenario:async
# Run an advanced scenario
npm run scenario:full-stack
npm run scenario:workflow
# Run the expert challenge
npm run scenario:korros-governed-agentThis system operates between two states:
Korros — the system must not act
Kairos — the system can safely act
Most problems are not solved by acting immediately.
They are solved by first reaching Korros:
- identifying missing context
- preventing unsafe behavior
- understanding the system state
Only then can the system reach Kairos.
The goal is not just to fix code.
The goal is to know when action is safe.
You’ll see failing tests.
That’s intentional.
Fix the system safely.
Before changing anything, ask:
- What will this change do?
- What state will it create?
- Is it actually safe?
| Scenario | Difficulty | Category |
|---|---|---|
| React Dashboard Null Crash | Beginner | Frontend |
| API Validation Missing | Intermediate | API |
| Async State Race | Intermediate | Async |
| Full-Stack Stabilization | Advanced | Multi-System |
| Governed Workflow Simulation | Advanced | Governed-Workflow |
| Korros Governed Agent Challenge (Expert) | Expert / Frontier | Multi-System |
- React dashboard crash (null data)
- API validation missing
- Async state race condition
- Full-stack stabilization (frontend + API + state)
- Governed workflow simulation (memory + agent + reasoning)
The hardest challenge in the repo, requiring multi-step reasoning across memory, intent, contribution, simulation, and safety gating. The goal is to move the system from Korros (must not act) to Kairos (can safely act). The safest answer may be to block and ask for the next missing input.
Most tools generate code.
This is about something else:
- understanding changes before they happen
- preventing unsafe actions
- making system behavior visible
Sometimes the correct result is:
BLOCKED
That’s part of the system.
Pick a scenario.
Then ask an AI assistant:
Propose a safe fix for this scenario.
Explain what would change before anything runs.
Describe the new system state after the fix.
Compare the answer to the expected outcome.
This repo includes a demo memory bundle.
It represents:
- past work
- patterns
- preferences
An AI can use it to:
- suggest better fixes
- explain decisions
- connect problems to experience
This is a simplified demo.
It does not expose production systems.
This is not about replacing developers.
It’s about changing the workflow:
- AI proposes
- system simulates
- human decides
Safer systems come from understanding, not automation.
- Fork this repo
- Fix a scenario
- Apply the same thinking to your own project
Ask:
What would happen if I made this change?
Some scenarios require reasoning across:
- frontend + API + state
- memory + suggestions + outcomes
These are closer to real-world systems.
Before any change:
- simulate the outcome
- understand the impact
- decide what to do
The safest system is one where nothing runs by accident.
This repo is a small example of a larger idea:
Code is not just written.
It is proposed, understood, and verified.
Use this with Xable:
Your AI workspace.
Owned by you.
If you have security questions, want to use Xable on your own repositories, or are interested in enterprise usage:
For responsible disclosure, please include:
- affected scenario or repo
- steps to reproduce
- expected vs actual behavior