A workspace for thinking, not just tracking

Most ideas die in the gap
between the thought and
the first commit.

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.

Plate IV · Tour · 01:23What ninety seconds of Ideafy looks like, for the solo case.Unedited
Cloudopening soon

When it opens, the board comes with you. Across devices, across teammates.

Reserve a seat  →

No card today · Waitlist queue

Solo — open source

Or run it on your own machine. Single file, no network.

Download from GitHub

MIT · SQLite, single file · Works offline · Self-hostable

* Any edition — Solo or Team — needs Git, Node.js, and one coding CLI (Claude Code, Gemini CLI, Codex CLI, or OpenCode) installed and logged in once from your terminal before launch. Setup →

Curious first?How it works  →

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

A card, mid-thought
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’s the feature. Most boards say yes to everything; Ideafy will tell you when an idea is too early to code.

Ideas don’t arrive finished.

They arrive soft, partial, and half-wrong. “I have an idea” and “it is shipped” is not a single step — it is a chain of seven. Each link is a different kind of thinking, with its own stopping condition. Skipping one does not save time; it transfers the cost to a later stage, at a worse rate.

  1. 01

    I have a rough thought.

    Does this belong in my project at all?

  2. 02

    I have an opinion about it.

    Is it worth doing? What is the verdict, with reasons?

  3. 03

    I have a scope.

    What exactly does this become — and what does it not?

  4. 04

    I have a plan.

    What code changes, in what order, touching which files?

  5. 05

    I have an implementation.

    The code exists. In an isolated worktree, with tests alongside.

  6. 06

    I have acceptance tests.

    I will know it is done, because the finish line was written first.

  7. 07

    I have a shipped thing.

    And I know exactly when — and why — it crossed the line.

Written this way, a card stops being a reminder. It becomes an executable unit — enough structured context for an agent to act on it without asking you, and enough legibility for a second reader to pick it up three months later and know exactly why it exists.

Six columns.
Not a taxonomy. A spine.

A card moves right when the thinking on it has evolved enough to deserve the next column — not when a calendar or a standup says so. Each column is a different question the card has just finished answering.

ideafy·board7 cards · 1 refused
Ideation1
Backlog2
In Progress1
Completed2
Withdrawn1
Offline-first sync engine, CRDT, E2EEOffline-first sync
kan-098·scope · yagni
refused → filed, not deletedkan-098 · withdrawn apr 14
Fig. I — The boardWatch a card refused early. Ideation, a brief Backlog consideration, then filed in Withdrawn — receipts intact.
  1. 01

    Ideation

    The rough thought. No scope, no plan, no obligation.

  2. 02

    Backlog

    Scoped and opinion-formed. A candidate the verdict let through.

  3. 03

    Bugs

    A different shape of reasoning — from 'wrong' to 'fixed.'

  4. 04

    In Progress

    Plan in place, worktree claimed, implementation underway.

  5. 05

    Human Test

    Code written, acceptance list attached, waiting on a human.

  6. 06

    Completed

    Shipped — and preserved, chain intact, for the next reader.

From thought, to argument, to artifact.

  1. I

    It reads you, before you ask it to.

    On first run, Ideafy scans your repo and writes a Product Narrative — the problem, the people, the features, the stack. This becomes the lens every new idea is measured against. Not a rubric someone else wrote. Yours.

    The narrative is a markdown file. You can edit it. It is yours.

  2. II

    It argues with the idea, not you.

    Every card triggers an Ideafication pass: YAGNI, feasibility, complexity, an honest verdict. Weak ideas are told so, in writing, with reasoning attached. Strong ideas earn a plan. Sometimes the answer is don't build yet.

    The verdict is never hidden. You can disagree — in writing.

  3. III

    Only then, does it write code.

    When the argument holds, execution begins — in an isolated git worktree, with tests it drafted itself, on a branch that will not touch main until a human says so. The code is the footnote. The thinking is the text.

    Autonomous or interactive. You choose, per card.

The Opinion tab,
writing itself.

One card, four tabs — Detail, Opinion, Solution, Tests. The screenshot below is the Opinion tab in the wild: the agent has read the Product Narrative, weighed YAGNI against feasibility, and filed a verdict in plain language. No mockups, no renderings, no stock UI.

kan-114Manual export/import (.ideafy file)Backlog
Detail
Opinion
Solution
Tests
reading product narrative…
Strong yes. Ship the smaller card.
  • scope is well-bounded — one file format, one button, no accounts
  • risk is low — pure file IO, no state migration, no network
  • value is concrete — unblocks the empty-board pain in one afternoon
yagni 8/10feasibility 9/10risk 2/10
verdict · 87 / 100
Fig. II — The Opinion tabThe Opinion tab, writing itself. A headline, three reasons, three scores, and a verdict stamped in rose. Each tab is its own conversation, its own chat history.

The model proposes.
You still hold the pen.

Agents

Claude Code, Gemini CLI, Codex CLI — wired through MCP.

The board exposes itself to the agent through Model Context Protocol tools. Cards move, plans save, tests attach, without copy-paste between windows. Per-card override on which agent runs.

Isolation

A git worktree and a dev server, per card.

Every card in In Progress owns a dedicated git worktree and a dev server on its own port. Main stays clean. You can run two features side by side without either one knowing.

Lenses

Four tabs, four kinds of thinking.

Detail, Opinion, Solution, Tests. Each tab answers a different question about the card — what it is, whether it is worth doing, how it gets built, how you will know it is done. Collapsing them collapses the thought.

Team

A shared pool, pulled — not assigned.

In the team edition, cards land in a pool anyone can pull from. Assignment-first workflows pretend the thinking is already done. Evolution-first workflows admit it is still happening.

ideafy·cloud poolunclaimed · pull when ready
pool · 4 cards
Reduce cold-start time on Electron
kan-241·high · 2d estclaiming…
Add per-card chat-history export
kan-238·med · 1d est
Mention chip auto-complete on '@'
kan-235·low · half-day
Worktree garbage collection on cold start
kan-228·med · 1d est
activity
mmaya pulled kan-241
in progress · @maya
Reduce cold-start time on Electron
ozan · sara · idle · pulling next
Fig. III — The poolUnclaimed cards wait in the pool. Maya pulls one when she is ready to argue with it — not when a manager decides she is free. The pull is the answer.

Ideafy is for.

  • Solo founders
    who want one pane of glass for “what should I build, what am I building, what is done” — with the agent as a second pilot, not a separate tab.
  • Solo founders and small teams
    who want the board to follow them across devices, or to share work through a pull-based pool without the ceremony of Jira.
  • People already living in Claude Code
    who are tired of losing context between sessions and want a board that survives sleep.

How to start.

Solo is open source, free forever, and runs entirely on your machine. Team is hosted, ships with a shared pool, and is opening to a small waitlist first. Both editions speak the same six columns and the same chain of thought.

Solo / open sourcefree, forever

The Solo edition

For the founder shipping a project alone — a single-user kanban that lives in a single file you control.

  • SQLite database, single-file backup
  • Works offline, no external dependencies
  • Desktop app (macOS) with native experience
  • Claude Code, Gemini CLI, or Codex CLI
Download from GitHub
Team / cloudComing soon · waitlist

The Team edition

For solo founders who want remote access from any device, and for small teams pulling work from a shared pool — with the same chain of thought visible to everyone.

  • Everything in Solo, plus team features
  • Cloud Pool: push, pull, and claim tasks
  • Remote card creation from the web, straight into the pool
  • Per-card discussions with the agent and the team
  • Role-based access: owner, admin, member
  • Solo $5 · Team $12/3 seats · Team+ $20/6 seats — annual saves ~17%
Join the waitlist  →
Already on the team? Download:Apple Silicon·Intel
MIT License·Zero Config·SQLite — No DB Setup·Works Offline

* Either edition drives your coding agent locally, so before you launch you need Git and Node.js installed, plus at least one coding CLI (Claude Code, Gemini CLI, Codex CLI, or OpenCode) logged in once from your terminal (e.g. run claude and sign in). Two-minute setup — full steps in the README.

One command. No excuses.

Start building in sixty seconds.

Download for macOS

Apple Silicon & Intel — auto-updates via GitHub releases

For developers — build from source
$ git clone https://github.com/ozangencer/ideafy
$ cd ideafy && npm install
$ npm run electron

Envoi

Stop tracking ideas.
Argue with them.