Early access

For builders working with AI · in development

Keep what youalready got right.

You finally get it right. The next agent changes it. Kraddle carries what you’ve decided—and why—into each task, then checks changes against those decisions.

Explore the workflow

In development. Early-access signups open soon.

See one small change go wrong

Why agents break what already worked

Let’s say you wanted
to add search.

Your projects list already works the way you like it. You just want a search box. So you ask your agent.

01 / 04Too little context

A small change.An old problem.

Search works. But your active filter is gone, and paused projects are back in the list. The agent added what you asked for without knowing what you wanted to keep.

“Wait. Where did my filters go?”

What comes backIllustrative scene

my projectssearch
launch
Status: activeremovedRecently updated
Launch website Active
2 min ago
Launch checklist Active
3 days ago
Launch archivePaused · shouldn’t appear here
last month
Search added. Existing behavior lost.

The feature works on its own. The list no longer works the way you chose.

Next: The explanation

02 / 04Too much to sort through

You explain.Again.

You find the old chat. Paste your notes. Point to the rules. Now you’re reconstructing the reasoning behind a feature you’d already finished.

“We already talked about this.”

What you give the agentIllustrative scene

context for this tasknotes + chats
previous-sessionchat

“Let’s start with alphabetical order…”

product-notes.mdnotes

Saved views, project cards, status labels…

the choice that matteredsomewhere in here

Keep active filters when searching.

You remember the decision.
Now you have to find it for the agent.

More context. The important choice is still buried.

Your decision is somewhere in the pile. Finding it becomes another task.

Next: The old choice

03 / 04Context that fell behind

It remembersthe old version.

The agent finds a sorting rule. Unfortunately, it’s the one you replaced last week. The filters return, but alphabetical order comes back with them.

“We moved on from that.”

What comes backIllustrative scene

my projectssearch
launch
Status: activeA → Z · old choice
Launch checklist Active
3 days ago
Launch website Active
2 min ago
A past decision returns as the current one.

The rule survived. The reason you changed it didn’t travel with it.

Next: With Kraddle

04 / 04The workflow we’re building

The next feature.Still your project.

The task starts with your current decisions and their reasons. The agent knows what to preserve, checks the change against it, and leaves the new questions visible.

A new feature. Less defending the old ones.

What stays connected to the taskIllustrative scene

my projectssearch
launch
Status: activeRecently updated
Launch website Active
2 min ago
Launch checklist Active
3 days ago

Current decisions · carried into this task

Search keeps active filtersYour decision · so paused work stays out of the way

Recently updated comes firstYour decision · so you can resume your work

Checked: search + filters + sorting

Search added. Filters and sorting checked together.

The new “no results” screen is still an open question for you to review.

A project with a memory

Your choices.Their reasons.Still connected.

Chats move on. Decisions should stay useful.

01

Keep the why.

Capture a choice as you work, along with its reason and the alternatives you ruled out.

DecisionRecently updated first“I want to resume what I was working on.”
02

Carry it forward.

Connect it to the parts of your project it affects. Bring the relevant choices into the next task.

Next task · add searchPreserve filters and sortingLinked to the projects list and your earlier choice.
03

Check what changed.

See what was checked, what conflicts, and what still needs your judgment. Revisit a decision when it stops fitting.

ReviewSearch respects the existing listFilters and sorting checked. The new empty state needs a look.

The workflow we’re building · examples are illustrative

The workflow we’re building

Start anywhere.It keeps up.

Four ways in. One connected project.

Scroll to explore

01 / 04

Bring your codebase

  1. Bring the code you already have.
  2. See what it does, what’s been decided, and what’s still a guess.
  3. Make the next change with those choices in view.
Product concept · Bring your codebase

Start with what exists.

  • Observed: projects list has filters
  • Your decision: recently updated first
  • Open question: what happens with no results?

Connected to your project. Carried into the next task.

02 / 04

Start from an idea

  1. Describe what’s in your head.
  2. Work through the choices that shape it.
  3. Give agents a direction you can inspect and revise.
Product concept · Start from an idea

Make the idea concrete.

  • Intent: help me finish my side projects
  • Choice: one place for active work
  • Still open: what belongs on the first screen?

Connected to your project. Carried into the next task.

03 / 04

Come back after a break

  1. Return after a few weeks.
  2. Find the decisions, their reasons, and unfinished questions.
  3. Pick up the thread without rebuilding the whole context.
Product concept · Come back after a break

Your past self left a trail.

  • Chosen: active projects come first
  • Why: less hunting, more finishing
  • Parked: shared projects with friends

Connected to your project. Carried into the next task.

04 / 04

Try a wild idea

  1. Suggest a new direction.
  2. See which choices and parts it would affect.
  3. Explore an alternative without losing the reason for the original.
Product concept · Try a wild idea

Change your mind on purpose.

  • What if: group projects by client?
  • Touches: navigation and saved filters
  • Keep: the current approach and its reasons

Connected to your project. Carried into the next task.

01 / 04Keep scrolling. There’s more than one way to begin.

Product preview · the workspace we’re building

One calm placeto build.

my-projectsWorkflow previewF

Search projects

session · started 4 min ago

Add search to my projects

Plan

  • Add search using the shared list component
  • Keep active filters while searching
  • Preserve recently-updated sorting
Checks2 passed
✓ Search respects active filters
Existing decision
✓ Recently updated still comes first

Filters and sorting checked. The new “no results” screen still needs your eye.

What if we grouped projects by client?

You chose one flat list so personal projects wouldn’t need a client. Grouping would affect navigation, saved filters, and projects without a client.

currentOne flat list
alternativeClient groups
  • One component, many looks23×
  • Errors say how to fix them41×
  • UI uses shared components17×
  • No new dependency without a reason9×
src/ui/price.tsx one component, many looks
1export function PriceTag()   { … }
2export function PriceLabel() { … }
3export function PriceBadge() { … }
4export function Price({ variant }) { … }

Why Copies drift, and drift is where bugs live.

The next task starts with the decisions you’ve already made.

See what a new direction touches. Keep the reason for the old one.

The way you like to build becomes part of the project.

What changes

Less babysitting.More building.

Keep your direction.

New work starts from the choices that made your project yours.

Less starting over.

Your reasons stay connected when sessions and agents change.

See what needs you.

Checks, conflicts, and open questions give your attention somewhere useful to go.

Questions

Good questions.

What is Kraddle, exactly?

A workspace we’re building for people who build with AI. It connects what you’ve decided, why you chose it, and the parts of your project it affects—so those choices can guide agent work and be checked as the project changes.

How is this different from a CLAUDE.md or a rules file?

A rules file is useful, but someone has to keep it current and the agent has to follow it. Kraddle’s direction is to connect decisions to code, reasons, and checks: show when the context has changed, bring the relevant choices into a task, and check governed changes against them.

Am I going to spend all day approving decisions?

That would defeat the point. The intended workflow captures decisions as you work and brings consequential choices to your attention. Routine acceptance can follow permissions you’ve already given. The interaction is still being developed; reducing that ceremony is a core product requirement.

Does my code leave my machine?

The current foundation runs locally and stores its workspace beside your project. If you use a cloud coding agent, that agent may send code or context to its model provider. Local storage doesn’t change the data policy of the agent you choose.

Which languages does it support?

The current prototype analyzes JavaScript and TypeScript imports. Broader parsing and semantic indexing are next. We’ll publish supported languages as the adapters are built and checked.

Can I use it with the agents I already use?

The prototype exposes a small MCP interface that compatible clients can use for checked file writes. The full decision-aware workspace and harness are still being built. The goal is to keep your project’s decisions useful across agents, rather than tie them to one model.

What if I change my mind?

That’s part of the design. Revisit a choice, see the reasons and connected parts, and explore a different direction. Keep the earlier rationale in history so a future agent can understand why things changed.

Does it guarantee an agent can’t break anything?

No. The current prototype checks a narrow set of architecture rules before writes made through its tools, and detects unapproved file changes when a session finishes. It isn’t a sandbox. The broader product is being built to make its checks, gaps, and conflicts visible so you can judge what’s actually established.

What’s ready today?

The local control foundation and a small agent interface exist. Continuous indexing, conversation-based decision capture, and the full workspace are still in development. The scenes on this page illustrate that intended workflow; they aren’t recordings of a shipping app.

Build the next thing.Keep what matters.

Your ideas can change. The reasons behind them don’t have to disappear.

Explore the workflow

In development. Early-access signups open soon.

  • Local first
  • Built for coding agents
  • In development