Build verdict · 9/10— Filed 13 April, 2026

An idea is worth
thinking about
before it is worth writing.

Ideafy is a kanban for builders who treat ideas as arguments, not tickets. The board reads your project, challenges your next move, plans with you in plain English, and only then writes the code. Built for solo founders and small teams who already work with Claude Code, Gemini, or Codex — and want a board that survives between sessions.

§ Editor's note — The interesting work is not the code. It is the argument for the code. We built a kanban that keeps both.

Start thinking out loud →How it works →

Just want to see it? → for founders · for developers

The interesting work happens
before anything is written.

The Product Narrative being written interactively on first run, with story behind, problem, target users, core features, non-goals, tech stack, and success metrics fields — Fig. 1The Product Narrative is written interactively on first run. From this moment on, every card is measured against the document above.Plate

Every code-generation tool optimizes for the moment a file is touched. That moment is the cheapest part of building software. The expensive part — the part that decides whether the product survives — is the conversation that should have happened first.

Ideafy puts that conversation on the board. A card is not a ticket; it is a position you are taking. The model reads the narrative of your product and pushes back. Sometimes it agrees. Sometimes it asks you to defend yourself. Sometimes it says this is the wrong week for this idea.

When the argument is settled, the model writes the code. Not before. The columns of the board are the stages of a thought turning into a shipped change, in order, with nothing skipped.

A card, mid-thought.

An actual exchange from a paying user, lightly edited for length. The model reads the product narrative, asks three questions back, scores the idea, and refuses. That refusal is the feature.

KAN-114Add a referral program for paying users

§ Ideation

you

referral program — credits both sides, applied next invoice

ideafy

reading product narrative…
your audience is solo founders on a $19/mo tier. referrals usually need a viral surface — your product has none yet. asking three questions before scoring.

— what’s the surface? landing page only?
— is churn or acquisition the bottleneck?
— do paying users actually advocate today?

YAGNI

5 / 10

Feasibility

8 / 10

Complexity

6 / 10

verdictdon’t build yet▍

— The model can refuse. That is the feature. Most boards say yes to everything; Ideafy will tell you when an idea is too early to code.

Sixty seconds with the board.

A hand-drawn technical diagram plotting the evolution of an idea across the five kanban stations — Ideation, Backlog, In Progress, Human Test, Completed — with a single card marked in ember wax seal — Fig. 2The evolution of an idea, plotted across five stations. One card is marked in wax — the one the model is arguing with today.Plate

A card in Ideafy travels through the diagram above in six steps — but the whole arc is really three movements, repeating at different scales across the page.

It reads you, before you ask.

On first run, the model writes your Product Narrative — the lens every future idea is measured against.

II.

It argues with the idea, not you.

Every card earns a verdict in writing: YAGNI, feasibility, complexity. Weak ideas are told so, with reasoning attached.

III.

Only then, does it write code.

Execution happens in an isolated worktree, with tests the model drafted itself. A human gate stands between it and main.

The same arc, in six motions

I
Capture.You drop an idea — title, complexity, one line of detail. The card lands in Ideation, untouched by the model. Pure capture, no AI interruption.
tracequick entry · ⌘N → Ideation
II
Evaluate.You ask for an opinion. The model reads your Product Narrative, scores the idea against it — YAGNI, feasibility, complexity — and files a verdict in writing. Sometimes it tells you to wait.
traceevaluate → save_opinion
III
Plan.You open the Solution tab, or drop into Claude's plan mode in your terminal. Argue the architecture, refine the scope, sign the plan. The card moves to In Progress and an isolated git worktree is born for the work.
tracesave_plan → /worktrees/feat-xyz
IV
Build.Run autonomous, or stay in the interactive session. Implementation happens on its own branch, with its own dev server, on its own port. main is untouched. You keep working on something else.
traceautonomous · localhost:5174
V
Test.When the work is done, the model files acceptance criteria and slides the card into Human Test. You tick the boxes by hand. If something is wrong, you say so — and it fixes, commits, and pushes without you ever opening an IDE.
tracesave_tests → Human Test
VI
Ship.You merge from the card modal. Ideafy rebases onto main, surfaces conflicts as a file list (or asks the model to resolve them), and cleans up the worktree behind itself. The card lands in Completed with the full chain of thought attached.
tracemerge → squash → main

The Ideafy board in day mode, showing all seven columns including Ideation, Backlog, Bugs, In Progress, Human Test, Completed, and Withdrawn — Fig. 3The diagram, in software. The same chain of five stations — plus Bugs, where the chain runs in reverse, and Withdrawn, where it is preserved.Plate

— Six motions. The board is the chain made physical. The hand drew it first; the software lives it second.

Four lenses on the same card.

Every Ideafy card carries four tabs. They are the four angles you need to look at any piece of work from — and the four questions you would ask about any idea. Collapsing them into a single description field collapses the thought. Separation is the act of respect.

The Detail tab of an Ideafy card titled PIN-based Device Pairing for Remote AI Operations, showing description, constraints, and context fields — Description, constraints, context. The idea as given.

The AI Opinion tab of the same card, showing a Strong Yes verdict with strengths, recommendations, priority, complexity, and risk score sections — Evaluation against goals, non-goals, risks. The verdict, with reasons attached.

The Solution tab of the same card, showing the architecture, electron parts, components, and file changes for the implementation — Plan, sequence, files touched, trade-offs. The blueprint, written before the first commit.

The Tests tab of the same card, showing PIN generation tests, device pairing tests, security tests, and edge cases — Acceptance criteria, written before the finish line so done is a fact, not a feeling.

— The same card, four times. One title. One git branch. Four kinds of thinking, kept apart so none of them leak into the others. This is what philosophy.md calls “four lenses on the same card” — not a metaphor.

Two editions, one thinking layer.

Ideafy ships in two forms. The local version is the whole product — open source, file-based, yours to run. The cloud version adds the team fabric — a shared pool, role-based access, managed hosting. The reasoning layer is identical.

Edition I

Solo Builder

Free, forever. Open source.

The whole product, file-based and local. SQLite on disk, single-file backup. Runs offline, no external dependencies. Desktop app for macOS with native performance.

Plug in Claude Code, Gemini CLI, or Codex CLI — whichever agent you already trust. MIT licensed; clone the repo and run it yourself.

Clone from GitHub →

Edition II

Cloud Team

$5 per seat, per month.
or $50 per year — two months free.

Everything in Solo, with a shared fabric on top. A Cloud Pool where your team pushes, pulls, and claims tasks. Role-based access for owner, admin, and member.

File new cards from any browser, and argue them out with the model right there — no desktop app required to open the thread. The web is a first-class surface — for you, for your phone, and for any teammate you bring along.

Managed hosting, zero setup. For solo founders who want the board to follow them across devices, and for small teams who want a shared pool without running their own server.

Start thinking out loud →

— or, simpler —

One command to start.
Zero excuses left.

Start building in sixty seconds. No sign-up, no trial, no credit card.

Download for macOS ↓

Apple Silicon & Intel · auto-updates via GitHub Releases

— or, for developers —

$ git clone https://github.com/ozangencer/ideafy

$ cd ideafy && npm install

$ npm run electron

MIT licensed. Build it yourself, run it yourself, own it yourself.

§ A letter from the author

On twenty years,
and what changed.

From Ozan · April 2026

I spent twenty years building enterprise software — shipping it, consulting for teams trying to ship it, watching how large organisations turn ideas into code. In all that time, one thing stayed consistent: the ability to form a complex, structured, durable chain of thought about a product was the exclusive property of a very small group of specialists. Architects. Lead engineers. Senior analysts. A handful of people who could hold the whole problem in their head and walk it from rough idea to production system without the thread snapping.

Everyone else was structurally locked out. Not because they had nothing to contribute — but because the distance between “I have an idea” and “the idea is running on a server” required a kind of clustered, disciplined thinking that enterprise tools didn’t teach and enterprise processes didn’t democratise. They just enforced.

Then AI changed the unit economics of all of this. Ideas are, for the first time in my career, actually democratised. A founder with taste can prototype in a weekend. A domain expert can describe a workflow in plain language and have working code thirty minutes later. That much is real, and it’s already happening.

But the shift I care about is not everyone uses AI. It is everyone collaborates with AI as a team — and inherits an enterprise-grade chain of thought capability they never had access to before.

The difference between using an AI and being on a team with one is the same difference as between typing a query into Google and pair-programming with a senior engineer. One is a transaction. The other is a chain of thought shared between two minds, held together over time, with structure.

This is what I wanted to build a tool for. Not AI on the side. AI as a team member inside a disciplined surface — columns, plans, tests, verifications — where the chain of thought that used to belong only to enterprise architects becomes something a founder, an analyst, or a first-time builder can inhabit. Ideafy is my attempt to bring people one step closer to that.

Ozan

İstanbul · April 2026

P.S. — If any of this resonated, Find this on GitHub · — ★