The Perfect Handoff
No gaps from idea to execution.
Every time a feature brief passes from product to engineering, something gets lost. ArcLume keeps the full context intact — turning transcripts and briefs into codebase-grounded stories that engineering can actually act on, with a Context Bundle that carries the thread all the way to shipped code.
"We need to rework the notification preferences flow. Users keep disabling all notifications because the granularity isn't there..."
Every handoff is a place where
context gets stripped away.
The gap between what was requested and what shipped isn't a communication failure. It's what happens when information has to be re-encoded by hand at every stage.
A customer reports a problem with full context — what they were trying to do, how many times they tried, the workarounds they invented. Support logs it. By the time it reaches product, it's a one-line ticket.
Product writes a spec in user-facing terms. Engineering gets it and immediately asks: which service owns this? What does the data model look like? What else breaks if we change this? The spec didn't answer those questions.
The ticket gets closed. Nobody checks whether what shipped matches what was originally requested. The loop never closes — so the same gap that caused the problem stays open for the next cycle.
The work you do compensating for these gaps — the clarification threads, the sprint planning back-and-forths, the post-launch "that's not what I meant" conversations — isn't inherent to software development. It's the tax you pay when context doesn't survive the handoff.
How ArcLume Closes It
Five stages. Nothing lost.
Each stage carries the full context of the one before it. No re-encoding, no gaps.
Brief, transcript, or support thread
Upload a meeting recording, paste a written brief, or pull in a cluster of support tickets. The original context arrives intact — nothing is discarded before the loop starts.
Structured epics and stories
ArcLume extracts the intent and generates a structured plan: epics, stories, acceptance criteria, and open questions. Every claim is grounded in what your codebase can actually support.
Codebase-grounded tickets
Stories arrive at engineering with the implementation context already resolved — specific files, functions, and downstream dependencies. Not "update the user service." The actual file path.
Context Bundles for AI coding tools
Engineers export a Context Bundle — a structured prompt containing story details, relevant code snippets, and architectural context — and hand it off to Lovable, Cursor, or Claude Code.
Intent preserved end to end
Because the original intent was captured in structured form, anyone can verify that what shipped matches what was asked for — without reading a diff or re-interviewing the team.
Support sees what changed. Product can verify the shipped feature matches the original intent. Feedback re-enters as input — and the cycle runs again without losing ground.
What each team gets
The same structural model powers both sides of the handoff.
Product & Support
Your intent, translated into engineering language
Upload a brief, meeting transcript, or cluster of support tickets. ArcLume turns it into a structured backlog that engineering can act on immediately — no clarification required, no sprint planning back-and-forth.
- Transcripts and briefs become structured epics with acceptance criteria
- Open questions and assumptions are surfaced before the ticket gets to engineering
- Push directly to Linear with one click
Engineering
Tickets that already know what to touch
Stories arrive with the implementation context already resolved — specific files, functions, and downstream dependencies. Export a Context Bundle and hand it off to Lovable, Cursor, or Claude Code to implement.
- Real file paths, function signatures, and confidence-scored dependencies
- Context Bundles carry the full thread into Lovable, Cursor, and Claude Code
- Connect your IDE via MCP for live cross-repo architecture queries
Why the context gap is hard
to close with existing tools.
Tools like Copilot and Cursor search for relevant code. They find it by similarity — the text that sounds closest to what you're describing. That works well for autocomplete. It doesn't work for the planning-to-implementation handoff.
Closing the handoff gap requires knowing what connects to what. Which service calls this endpoint. Which Kafka consumer reads this topic. Which downstream component breaks if you change this interface. Similarity search can't answer those questions — it can only guess.
ArcLume resolves connections structurally through AST-level code analysis. It parses your syntax tree, maps your call graph, and performs cross-repo dependency resolution with explicit confidence scoring. That's what makes it possible for a story to arrive at engineering with the implementation context already in it — not reconstructed from memory, but read directly from the codebase.
Under the Hood
The structural model that makes lossless handoffs possible
Every story is grounded in a real model of your codebase — not embeddings, not guesses. AST-level symbols, resolved dependencies, and confidence-scored cross-service connections.
Structural Codebase Model
One structural model of your entire system — whether that's one repo or thirty. Functions, classes, interfaces, and the connections between them, resolved at the AST level. Not embeddings. Not text search. The actual graph.
Dependency Confidence Scoring
Cross-repo connections aren't always clean. ArcLume scores every inferred dependency — confirmed connections are stated as hard requirements, likely ones are flagged for review, and uncertain ones become explicit open questions. No hidden assumptions.
Interface Point Mapping
REST endpoints, Kafka topics, BullMQ queues, gRPC services — ArcLume detects and maps every cross-service interface point. When a story says "update this endpoint," downstream impact mapping already knows what it touches.
Works for monorepos and
distributed systems alike.
The handoff problem doesn't care how your code is organized. A large monorepo has the same cross-module dependencies, shared interfaces, and layered call graphs as a distributed system — and the same need for context that survives the trip to engineering. ArcLume builds the same structural understanding regardless.
Frequently asked questions
What is ArcLume?
ArcLume closes the gap between product, engineering, and support. It turns meeting transcripts and briefs into codebase-grounded stories — so engineers get tickets that already know which files to touch and which dependencies are involved. The original intent survives every handoff intact, from the first conversation to shipped code.
What's a Context Bundle?
A Context Bundle is a structured prompt generated from a story's details plus relevant code from your codebase — file paths, function signatures, architectural context, and dependency relationships. Engineers copy it (or download it as .md) and paste it into Lovable, Cursor, or Claude Code. The full context travels with the ticket all the way to implementation.
Does ArcLume have an MCP server?
Yes. ArcLume exposes your codebase's structural model as an MCP server, compatible with Cursor, Claude Code, VS Code, and any MCP-compatible AI assistant. Once connected, your AI assistant can answer cross-repo questions structurally — not by guessing from text similarity, but by traversing the actual dependency graph. Setup takes about two minutes via OAuth.
How is this different from Copilot or Cursor?
Copilot and Cursor search for code by similarity — text that sounds closest to your description. That works for autocomplete, not for planning. ArcLume resolves connections structurally: it parses your AST, maps your call graph, and fuzzy-matches cross-repo interface points with confidence scoring. When a story says "update this endpoint," it already knows which downstream consumers are affected.
Does it work with monorepos?
Yes. A 200-file monorepo has just as much internal complexity as a distributed system — cross-module dependencies, shared interfaces, layered call graphs. ArcLume builds the same structural understanding regardless of how your code is organized.
What integrations are supported?
GitHub for repository connections and OAuth login. Linear for one-click epic and story push. MCP server for Cursor, Claude Code, VS Code, and any MCP-compatible AI assistant. All integrations are straightforward OAuth-based setup.
Is my code safe?
Your code is accessed through GitHub's App API with scoped permissions. Code is sent to Claude for generation only when you trigger it. We never train on your code or share it with other customers.
Is ArcLume free during beta?
Yes. ArcLume is currently in beta and free to use. Sign up to get early access and help shape the product. Pricing will be introduced after the beta period.