The new hire spends week one asking where checkout lives.
Stacklens reads your code and draws a map of what you are building and how it works. Re-run it and the map follows the code.
Shop
Lines show two flows. Checkout page calls Payments API, which calls Payments. Orders API calls Order service.
Frontend
-
- pages/
index.tsx - components/
ProductGrid.tsx
- pages/
-
- components/
Cart.tsx - hooks/
useCart.ts
- components/
-
- pages/
checkout.tsx - components/
PayButton.tsx
- pages/
Middleware
-
- api/
auth.py - api/
session.py
- api/
-
- api/
orders.py
- api/
-
- api/
payments.py
- api/
Backend
-
- users/
models.py - users/
service.py
- users/
-
- orders/
service.py - orders/
models.py
- orders/
-
- payments/
charge.py - payments/
refund.py - payments/
stripe_client.py
Why: card data never touches our servers, so payments run as their own service.
- payments/
-
- db/
schema.sql - db/
migrations.sql
- db/
How it works
There is no diagram to draw and nothing to keep in sync by hand.
Point it at a repo
Choose a folder on your machine. A monorepo, one service or a Power Platform solution export all work.
It maps locally
A parser on your machine reads the code and finds components, imports, routes and calls. Only that structure goes on to the AI step, which groups it into layers.
Drill in
Open the map and drill from the whole product down to a single file.
What it is, how it works, why it is that way
Most diagrams answer one of these questions. Stacklens puts what and how on the same map today, with why coming next, so you do not have to hunt across a wiki, a slide deck and someone's memory.
What
A nested map
Product, then Frontend, Middleware and Backend, then the components inside each. Open any box and you see its parts. A new hire finds checkout in a minute instead of a week.
How
Flows across components
Follow a request from the checkout button through the Payments API to the payment service.
Why
Decisions per component Coming soon
Write down why payments run as their own service, right on that component.
Impact preview (experimental): see which components a change is likely to touch. Not part of the first release.
Your code stays yours
The parser runs on your machine. When AI is involved, it receives names and relationships between components. It does not receive source code.
Structure only
The AI sees something like "Orders API calls Payments". Function bodies, comments, secrets and config values stay on disk.
Local parsing
Nothing is uploaded to build the map. Without AI, grouping runs entirely on your machine.
Your own cloud
On the Enterprise plan, run it in your own cloud, behind your own SSO.
Supported stacks
Parsers are built per language, so the map reflects how each framework really wires things together.
- JavaScript and TypeScriptNext.js, React with Vite, React Router
- PythonFastAPI, Flask, Django, CrewAI
- JavaSpring Boot
- C#ASP.NET Core
- Power PlatformSolution exports
Use the AI you already pay for
Stacklens works with the model your team already has. Hosted credits are optional, on the Team plan.
- Claude Code
- Add the Stacklens MCP server and ask Claude Code to group your map.
- Your Anthropic API key
- Usage is billed to you, directly.
- ChatGPT plan
- Coming soon
- Local model
- Coming soon
Pricing
Early pricing, may change.
Free
- 1 editor
- Unlimited viewers
- Runs locally
- Bring your own AI
Team
- Viewers are free
- Shared maps for the whole team
- Optional hosted AI credits
Business
- Everything in Team
- SSO
- Audit log
- PR impact checks
Enterprise
- Self-host or your cloud
- Annual contract
- Security review support
Questions
Does my source code leave my machine?
No. The parser runs locally and only the structure (component names and how they connect) goes to the AI step. Without AI, nothing leaves at all.
How does the map stay current?
Re-run Stacklens after you change the code. The viewer marks anything that is new since you last looked.
Do I need to buy an AI subscription from you?
No. Use Claude Code or your own Anthropic API key today. ChatGPT plans and local models are coming. Hosted credits on the Team plan are optional.
Who counts as an editor?
Someone who runs the parser or edits the map and its decision notes. Teammates who open and read maps are viewers and cost nothing.
Can we run it inside our own cloud?
Yes, on the Enterprise plan. Self-hosting is the reason that plan exists. Join the waitlist and mention it, and we will set up a call.