cixStart free
← All docs

docs / for-solo-developers.md

For solo developers

You work alone on a handful of projects — a side project or two, a freelance client codebase, an indie product, a research repo. You use an AI coding assistant heavily. You've noticed it works great on small projects and badly on the bigger ones, and you suspect it's not the assistant's fault.

This page is for that suspicion. It's correct — and cix is the cheapest way to fix it.

What cix solves for you

The trap of solo work is the assumption that you'll remember.

You'll remember you already wrote a formatCurrency helper. You'll remember components live in src/components but utilities live in src/lib. You'll remember the users table has full_name, not name. You'll remember the migration order. You'll remember why that one helper has a slightly weird signature.

You won't.

Six months from now you'll come back and your AI assistant will write a formatMoney next to your existing formatCurrency, and you'll merge it because the diff looks right and you've forgotten about the original. A year later you have three currency formatters and no idea which is canonical.

cix is the system that remembers for you. The assistant queries the index before it writes, finds the helpers you wrote a year ago, and uses them instead of inventing replacements. Old projects re-open with full context in one query instead of an hour of file reading.

Why this beats how you work today

Without an index, your AI assistant typically:

  • Reads ten files to answer a question one targeted query could have answered.
  • Writes new helpers because it can't see the ones you already have.
  • References columns it remembers from training instead of looking at your actual schema.
  • Drops files in folders that don't match where similar files in your project already live.

With cix:

  • The first turn of any session orients the assistant correctly — your stack, entry points, schema, and major directories in one query.
  • Existing helpers surface before duplicates get written.
  • The schema view stops the "compiles fine, fails at runtime" category of column-name bug.
  • Convention rules — even ones you set six months ago and forgot — keep new files in the right place.

The setup is two commands. cix parses your code locally — your source never leaves your machine. Cloud-backed indexing and querying keep sessions fast and your usage transparent across machines. The cost: a few minutes of setup per project, a small amount of disk space, and the Individual plan.

What success looks like

A few weeks in, on a project where cix is the right fit:

  • Less duplication. You stop merging "new" helpers that turn out to mirror old ones.
  • Faster context recovery. Reopening a side project after a month away feels like reopening it after a day. The orientation step does the remembering for you.
  • Fewer compile-fine-runtime-broken bugs. Schema awareness catches the fabricated-column class of mistakes before they hit your tests.
  • Old conventions stick. Decisions you made six months ago are encoded once and applied consistently.

You can verify these on yourself: pick the project where you most often catch yourself thinking "wait, didn't I already write this?" Install cix there. Use it for two weeks. See whether the catch-yourself moments drop.

When NOT to use cix

Skip it if:

  • The project is one file or a throwaway script. Below ~50 source files, you can probably hold the whole thing in your head; the index is overkill.
  • The project is in a language without strong parser support today — primarily Lua, plus a handful of less-common languages. The system is honest about this; on those projects you'd see "no parser available" rather than fabricated answers, but the value to you is small. See Limitations.
  • You don't use an AI coding assistant. cix is infrastructure for assistants. There's no value without one.
  • You're greenfield with no conventions yet. You can use it, but you'll be writing the convention rules from scratch instead of having them inferred. The immediate payoff is smaller.

Where to start

Pick your largest active project — ideally one with a database, real routes, and at least a few hundred files. Run the install. Run the per-project init. Look at the inferred conventions, adjust if anything looks wrong, and use cix for a week.

The bet is that you'll notice the difference within a few sessions. The cost of the bet is small.

Where to go next

Keep reading

Browse all

Docs index →