Should I vibe code
Supertag-based outliner that turns notes into structured knowledge
A supertag is a type. Which makes your notes app a schema, and schemas don't have weekends — they have migrations.
?
Their verdict, the Plus price and the build-time estimate come from their entry, MIT-licensed. Checked 2026-08-04.
?
Our verdict, the regret score and everything below it. Editorial and unsponsored — nobody can pay to be moved.
The honest answer
why the verdict is what it is
Two products now carry this name, and knowing which one you are copying is the first decision. tana.inc today sells an agentic meeting platform — native video calls with agents doing work inside the conversation — while the supertag outliner everyone means when they say Tana has been renamed Tana Outliner and moved to its own subdomain, where Plus is still about ten dollars a month. The outliner is the interesting build, and the reason it does not fit in a weekend is that a supertag is not a tag. It is a type: named fields with defaults, inheritance from other tags, and a query engine that renders every node carrying the type as a live view. Write that and you have written a small database with an editor stapled to the front of it, which is fine, and then week two arrives — the week you rename a field, find four thousand nodes referencing the old shape, and discover you have also adopted a migration tool. None of this reaches another human being, which is exactly why it stays in the demo band rather than climbing out of it. The thing to watch is quieter: an outliner that works becomes the only place your commitments live, in a graph shape only your own code knows how to read.
What actually breaks
not "if". the specific failures.
- The schema, the first time you rename a field. Thousands of existing nodes carry the old shape, and there is no vendor who has already thought about that for you
- Live queries, once the graph passes a few tens of thousands of nodes and every keystroke re-evaluates a filter across all of them
- Export, which hands back Markdown containing your prose and none of your types — and the types were the entire reason you left a plain notes app
- Sync, the first time you edit offline on a phone and a laptop. Last-write-wins on a nested outline does not lose a character, it loses a subtree
- Undo across structural edits. Indenting a node moves everything beneath it, and an undo stack that records only text changes will cheerfully strand two hundred children
- The AI bill, once transcription and chat run against your own key with no credit meter in front of them
- Meeting transcription, if you copy that half. The outliner records other people now, which is a different question with a different body of law behind it
Is that you?
the verdict is a default, not a law
- It is yours alone, the data is local, and the format is one you could read in a text editor if the app stopped launching
- You want the outliner because building outliners is fun, and you would enjoy it even if you abandoned it in March
- The types stay small — a handful of tags with a few fields, rather than an ontology of your entire life
- Anything you genuinely cannot lose also exists somewhere boring, like a calendar or a task list you did not write
- It has become the only record of what you promised people, and you have never once restored from your own export
- You are adding the meeting transcription — that is a recording of other people, and it belongs in the conversation about consent rather than the one about note formats
- Colleagues are in it, at which point permissions, realtime editing and conflict resolution arrive together and none of them are weekend problems
- You are storing an encryption key with no recovery path, on the theory that you will remember
If you build it anyway
the checklist, then the prompt that enforces it
- Decide the on-disk format before the editor exists, and make it something a stranger could parse: SQLite with a documented schema, or JSON lines with a version field on every record.
- Version the schema from the first commit and write migrations as ordered, replayable scripts. You will rename a field in week two; the only question is whether that is an afternoon or a rewrite.
- Seed fifty thousand nodes on day one and keep them there. An outliner that feels pleasant with two hundred nodes tells you nothing, and every architectural decision you end up regretting is a query that was fine at that size.
- Build export before import, and make the export lossless — tag definitions, fields and edges, not just the text. Then write the importer that reads it back and diff the result.
- Treat AI as a reader, not a writer. If a model can create or edit nodes, every one of those edits should arrive as a reviewable proposal rather than a silent mutation of your graph.
- Undo has to operate on structural operations, not keystrokes. Test it by indenting a node with two hundred descendants and pressing undo.
- Back up to a second machine on a schedule, and restore from it once, deliberately, before you trust the thing with anything you would miss.
I am building a personal outliner where tags behave like types — named fields, defaults,
inheritance, and saved live queries over everything carrying a tag. Single user. Build in
this order and push back when I ask for the shiny parts first.
1. Before any UI, agree the storage format with me and write it down: a documented SQLite
schema, or versioned JSON lines. It has to be readable without my application.
2. Add schema versioning and a migration runner in the same commit as the first table.
Assume I will rename a field once real data exists, and show me what happens then.
3. Write the lossless exporter next — nodes, edges, tag definitions, field values — plus a
matching importer and a test that round-trips a graph and diffs it. Export before
features, every time.
4. Seed the development database with 50,000 nodes and keep it seeded. Refuse to tell me a
query is fast on the strength of a graph with two hundred nodes in it.
5. Then the outline editor: indent, outdent, collapse, move. Undo records structural
operations, not keystrokes. Demonstrate undo on a node with 200 descendants.
6. Then supertags as types: field definitions, defaults, inheritance. When I ask to change a
field's type, refuse to do it in place — generate a migration I can read and reverse.
7. Then live queries, with an index behind them. Say plainly which queries cannot be indexed
and will scan the graph.
8. Any AI feature is read-only by default. If a model proposes node edits, they arrive as a
diff I approve; generated content never mutates the graph directly.
9. Anything I tag as a commitment gets mirrored to a plain-text file on every save, so the
worst outcome of abandoning this project is a folder rather than a loss.
10. If I ask for meeting transcription, stop and tell me that recording other people is a
separate problem with consent law attached, and does not belong in the same afternoon
as an outliner.
11. Out of scope on purpose: multiplayer editing, mobile sync and end-to-end encryption. The
first two are distributed-systems work, and the third is a key I will lose.
12. Finish by telling me honestly what a $10 subscription buys here: somebody else owning the
migrations, the sync, and the day the query engine gets slow.That one keeps you out of trouble. For the prompt that actually builds it, canivibecodeit.com has one.
their build prompt ↗Or don’t build it
the boring option, and the way back out
You want the structure rather than the exercise. Ten dollars a month buys the entire boring middle of this — sync, migrations, a query engine that stays responsive at fifty thousand nodes — and none of that is where the fun is. The counter-argument is genuine and worth stating: a self-built outliner is one of the few tools where being the only user is an advantage, because you can hard-code your own ontology and skip all the generality that makes the commercial version complicated. Build it if you want to build it. Just do not tell yourself the reason was that ten dollars was too much.
$10/mo is cheaper than your weekend.
The exit is a format decision you make at the start or not at all. Write a nightly export that emits two things: Markdown for the human-readable prose, and a JSON file carrying tag definitions, field values and node edges with a schema version at the top. The Markdown is what you would drop into Obsidian on the day you quit. The JSON is the only reason your structure survives at all, because every other tool's importer will ignore it and you will be writing the mapping yourself. Test the restore path once while the graph is still small, since the day you actually need it is the day you cannot face it.
Actively developed open-source outliner with a query language over local files, the closest open thing to this shape.
Local-first open-source workspace whose database views are the typed-fields half of the idea, already solved.
Questions
Which Tana does this entry mean?
The outliner. The company has moved the name: tana.inc is now an agentic meeting platform built around video calls with in-call agents, and the supertag outliner that canivibecodeit rated has been renamed Tana Outliner at outliner.tana.inc. It is still sold, still developed, and still the thing people mean when they write about supertags — so the verdict is about that, and the pricing block follows it.
Why score this harder than Heptabase or Reflect?
Only slightly harder, and the difference is the type system. Those two store documents and cards, where the structure is arrangement or links. Here the structure is a schema with fields and inheritance, which means changing your mind about a tag is a data migration rather than a rename. That is the piece that keeps costing you time long after the editor stopped being interesting.
Is Markdown export enough of an exit?
Not on its own. Markdown carries the prose and drops the part you built the app for — which node is a project, which field held the deadline, which query produced the view you looked at every morning. If the exit matters, the export has to include tag definitions and field values as structured data, and you have to have imported it somewhere at least once.
Every week, someone ships something they shouldn’t have.
New verdicts, the worst thing that landed in the trap, and the occasional incident report. No other email, ever.
Typed objects and backlinks is a schema decision, and you have opinions about schemas.
Block references are the fun part. Block references at 50,000 blocks are the part that ends projects.
Markdown export gives you the cards back. The arrangement — which was the entire point — is not in the file.
last reviewed 2026-08-05 · verdict is editorial and unsponsored · shared entry data from canivibecodeit under MIT · not legal advice