In development · Join the beta

Pick up where you left off.

Stackmaps keeps your main goal, every detour and the reason you took it, and the way back in one map — so you, and soon your coding assistant, always know where the work stands.

Join the beta waitlist Explore the product

Accepted beta testers get every premium feature free for life. How the beta works

Checkout Interactive preview

Task tree

Ship checkoutAdd Stripe payment intentsRepair webhook verification

Active · depth 2

Repair webhook verification

Why Stripe rejects unsigned events in staging

Checklist

  • Reproduce the signature failure locally
  • Add the webhook secret to the staging config
  • Verify the handler with a test event

Open branches

  • Replay failed staging events
Interactive preview with an example project. Select a branch or switch to the map; nothing is saved.

The rabbit hole problem

You start with one goal. Then the detours start.

Building is fast — until it isn't. Three hours later you're several layers deep in a sub-task, and the original goal is buried somewhere in your tabs. Your coding assistant starts every new session knowing even less.

  1. 1

    You open a detour with good intent. Checkout needs payment intents, and that needs working webhooks. Reasonable.

  2. 2

    The detour opens another. Webhooks fail in staging, a config is missing, and suddenly you're replaying test events and forgetting why you started.

  3. 3

    Stackmaps keeps the thread. The goal, each detour and its reason, and the way back stay in one map you can return to at any time.

What it looks like

One map of the work, from the goal down to the next step.

The task tree on the left, the current task and its reason on the right, and a resume card that tells you where you stopped.

Stackmaps showing the Checkout project: a task tree on the left with Repair webhook verification selected, and on the right a resume card with the main goal, where you stopped and the next step, above the task's reason, actions and checklist.
Private beta build Screenshot with an example project.

  • Task tree

    The main goal stays at the top. Every branch hangs off the task that caused it.

  • Visual map

    See the whole shape of the work and the path you're on right now.

  • History

    Where you've been, in order — click an entry to jump back.

Explore the product in detail

Human context

Remember what you were building, and why.

Context isn't just what the code does. It's the goal, the detours, the decisions, and the one line that explains why you're in this file at all.

  • A reason on every branch

    Each detour records why you took it. Six minutes or six weeks later, that line is the difference between resuming and re-deriving.

  • The active path, highlighted

    The map shows the route from your goal to the task you're on, so a side quest can't quietly become the product.

  • Resume where you stopped

    Open a project and see the main goal, where you stopped and the next step from your checklist.

  • A trail back

    Navigation history keeps every task you visited, with times, so the way back is never guesswork.

  • Checklists on any task

    Paste a bullet list from anywhere and it becomes the current task's checklist.

  • Your data, readable

    Export the whole tree as JSON or Markdown — handy for pull-request notes and stand-ups.

AI context

Give your coding assistant the same context you have.

The same map that keeps you oriented can orient your assistant: the goal, the current task, why it exists and what comes next.

  • In the beta

    AI context checks

    With your own Anthropic, OpenAI or Gemini key, the editor extension can tell you where to return after a branch, warn when you're several detours deep (Focus Guardian), and write a note of the path that got you here.

  • Planned

    Context for your assistant

    Supported assistants will be able to read your Stackmaps context through an MCP integration, so a new session starts from where you stopped.

  • Planned

    Continue on mobile

    A mobile app to check where things stand and plan the next step away from your desk.

ConceptContext for your assistant
goal       Ship checkout
path       Ship checkout › Add Stripe payment intents
           › Repair webhook verification
why        Stripe rejects unsigned events in staging
blocker    Webhook secret missing from staging config
decided    Analytics events deferred until after launch
next       Add the secret, then verify the handler
Concept of the planned assistant integration, using the example project.

How it works

Stack the goal. Branch with intent. Find your way back.

One afternoon on the example project, step by step.

  1. Goal

    Ship checkout

    You start from the outcome, not the implementation detail. It stays at the top of the tree.

  2. Detour

    Repair webhook verification

    Payment intents need working webhooks. You open a branch and write down why: Stripe rejects unsigned events in staging.

  3. Blocker

    Missing staging configuration

    The webhook secret isn't in the staging config. It goes on the task's checklist so it can't be forgotten.

  4. Decision

    Defer analytics events

    Not needed to ship checkout. The branch stays in the tree with its reason, instead of pulling you sideways.

  5. Next action

    Add the secret, verify the handler

    Tomorrow morning the resume card opens right here, with the next unchecked item.

  6. Return

    Back to Ship checkout

    Mark the detour done and Stackmaps moves you back up to the task it branched from — one step closer to the goal you set out to finish.

The map of the example project at the end of the afternoon: the path from Ship checkout to Repair webhook verification highlighted, Order summary on mobile done, Analytics events parked as its own branch.
Private beta build The same afternoon on the map.

In the beta today, blockers and decisions live in branch reasons and checklists. Dedicated blocker and decision notes are planned — see the concept.

Early access

Help shape Stackmaps. Get every premium feature free for life.

  1. Join the waitlist. It registers your interest — no account, nothing else to do.
  2. We invite testers in batches as the build is ready for more people. Joining doesn't guarantee a place.
  3. Accepted testers keep every premium feature free for life, including future premium features. It covers Stackmaps itself, not your AI provider's charges or other subscriptions.

Join the beta waitlist

We use your email to contact you about the beta. See the privacy notice.

FAQ

Questions

Can I use Stackmaps now?

Not publicly yet. Stackmaps is in development and runs as a private beta — an editor extension for VS Code and compatible editors, plus a browser version. Join the waitlist to be considered for an invitation.

What does "every premium feature free for life" mean?

If you're accepted into the beta, you get all Stackmaps premium features at no cost for life, including premium features added later. It isn't a trial or a discount. It covers Stackmaps itself — not charges from AI providers or other services you use with it.

Does joining the waitlist guarantee a beta place?

No. The waitlist registers interest, and invitations go out in batches as the build is ready for more people.

Which coding assistants will it work with?

The plan is to provide project context to supported assistants through integrations such as MCP; the list of supported assistants isn't final. Stackmaps supplies context — it doesn't launch or run assistants, execute code or move your repositories. That stays with the tools you connect.

Is there a mobile app?

Not yet. Continuing your work from a phone is planned.

What happens to my email?

It's stored so we can contact you about the beta. Product updates are sent only if you tick that box, and you can ask for removal at any time — see the privacy notice.