DEV Community: Bojan Tomic

What AI Video Tools Actually Cost Per Finished Video

Bojan Tomic — Tue, 15 Sep 2026 19:31:00 +0000

The monthly price on an AI video tool is close to useless. You are not buying a month; you are buying some number of finished videos, and almost nobody prices it that way on the page you land on.

I keep pricing records for every tool in this directory, read off the vendor's own page and dated. There are 53 video tools in there, 49 with a checked record. Here is what that set actually looks like, and how to get from a monthly price to the number you care about.

"Free" means three different things

Of the 49 video tools where I could establish what the free offering is:

20 have a real free tier. It continues indefinitely, usually watermarked or limited.
12 have a free trial only. It ends. Calling this free is the most common piece of pricing theatre in the category.
17 have nothing free at all.

So when you see "free" on a video tool, it is closer to one chance in three that it means "free for fourteen days". Two tools in the set are even labeled freemium by their own submitters, yet have no free tier at all, which is why I check rather than take their word for it.

The price you see is often the annual one

Here is Pictory's pricing page as it loads:

The annual toggle is already on. You see $25, $35, and $119. The real month-to-month prices are the struck-through ones: $29, $59 and $199. That is not a trick unique to Pictory; it's pretty standard. It means the number in your head when you compare two tools is often a prepaid annual rate rather than what it would cost month to month.

Every price in our directory is the month-to-month figure for exactly this reason. Annual prepay is a separate decision from which tool to use.

Cost per video, from one of the few who publish it

TapVid does something unusual and genuinely helpful: it states credits and an estimated video count on the same card.

That lets you do the division the page is usually hiding:

plan	monthly	videos	per video
Pro	$49	about 20	$2.45
Max	$99	about 42	$2.36
Ultra	$199	about 150	$1.33

Note what the per-video column does that the monthly column cannot: the $199 plan is the cheapest one per video. Four times the monthly cost, roughly half the cost per video. If you compare entry tiers across vendors, you are comparing the worst rate each offers.

The asterisks matter too. "About 20 videos" assumes a length and a model. A longer clip or a better model eats more credits, so treat these as a ceiling.

What I actually paid

I tested Fotor Video Agent properly and wrote it up. Three finished videos, including one with an AI presenter, cost 949 credits. That is 316 credits each.

On their monthly plan, that works out to $12.65 a video. On the annual plan, $3.54. Same tool, same videos, a 3.5x spread depending only on how you pay.

Which is the real finding here: on a single tool, how you pay can move the cost per video more than switching vendors would.

So what do you actually try

I am not going to tell you which makes the best video, because I have not tested 53 tools. What I can tell you is which ones let you find out for yourself without paying, and that depends entirely on the job you are doing.

Making video from a text prompt. Runway and Pika both run $0 to $95 and both have a real free tier, so you can try either before deciding. OpenAI Sora has nothing free. Start with Runway or Pika, and see the three side by side in Runway vs Pika vs Sora.

Talking-head and avatar video. Synthesia is $0 to $89, HeyGen is $0 to $149, and both let you test for free. Synthesys starts at $29 and has no free tier. Synthesia has the lower ceiling of the two you can try, which matters because the top tier is where you end up. Full breakdown in HeyGen vs Synthesia vs Synthesys.

Cutting long video into shorts. Opus Clip at $0 to $29 is the cheapest ceiling of anything here and has a genuine free tier. Descript is $0 to $65 and also offers a free trial. Pictory is the one from the screenshot above: $29 to $199, and trial only. See Descript vs Opus Clip vs Pictory.

Notice the pattern across all three. In every group, the tool with no free tier is the one you cannot evaluate without a card, and in two of the three it is also not the cheapest. No group offers a better entry deal for paying up front.

If you want the smallest possible commitment in the category regardless of job, Screenweaver runs $0 to $9.99, the cheapest ceiling of any video tool I have a record for.

Now the part I did not expect. I sorted the whole category by entry price to find the bargains. Here are the eight cheapest:

seedance-2-0 $7.99 · artaivo $9 · animate-photo $9.90 · ray-3-2-ai $9.90 · seedancetwo $9.90 · recapo-ai $9.99 · youart $9.99 · kaiber $10

None of them have a free tier. ** Five are trial-only; three have nothing free at all. The cheapest-looking options in the category are precisely the ones where you cannot try before you commit a card.

That is not a conspiracy. It is just what a low entry price has to do: if you are charging $8 a month, you cannot also give the product away. But it does mean "cheapest" and "try it first" point at completely different shortlists, and the cheap end of a pricing table is the last place to start if you have not decided yet.

Every comparison above is in the full comparison index, which puts the real month-to-month prices side by side with the date each was checked.

Work it out before you subscribe

Three questions, in order:

Is the free thing a tier or a trial? If it ends, it is a sales process, not a price.
What is the month-to-month price? Toggle annual off before you compare anything.
How many finished videos does that buy? Divide. If the vendor will not tell you how many credits a video costs, generate one on the trial and read the balance before and after. That is the only number that survives contact with actual work.

The two tools I have real per-video numbers for range from $1.33 to $12.65. That is a 9x spread across two products, and the monthly sticker price on either one wouldn't have told you where you'd land.

Pricing in this directory is pulled from each vendor's page and includes the date it was checked, so you can see how stale it is. The video tools are all there.

Three Coding Agents, One Repo: What Actually Breaks

Bojan Tomic — Wed, 09 Sep 2026 10:44:39 +0000

My repo took 66 commits in the last seven days. Seventeen distinct agent branches merged in the last thirty. I wrote maybe a third of it by hand.

The agents are Claude Code instances, coordinated through Multica, a task board built for teams of humans and coding agents. You'll find plenty of posts about running one coding agent. This is about what happens when you run several against the same codebase at the same time, which is a different problem with a different failure list. Almost none of it is the failure people warn you about. The agents write fine code. What breaks is everything around the code.

The setup

Agents get assigned issues in Multica and work them independently, each opening its own pull request. One of them, Scout, does nothing but find AI tools worth adding to the directory, verify them against their own sources, and prepare a reviewed migration. Its brief ends with a line I deliberately added: never add anything without explicit approval.

Last 30 days: 33 runs, 94% succeeded, 18 minutes 44 seconds average duration, concurrency 6. Two failed with agent execution errors. Every run is on Claude Code with Opus.

Others build features. Looking at merged pull requests from the last month, the branch names tell you how varied it gets: feat/tool-screenshot-carousel, fix/carousel-arrow-styling, feat/dark-logo-guard, chore/retire-applied-2026-08-30-batch, feature/tool-comparison, blog/what-happened-to-codeium.

All of them run on one machine, against one checkout.

The working tree is the shared resource nobody warns you about

Git branches are cheap. The working directory is not, and there is exactly one of it.

In a single afternoon, my tree was on feat/dark-logo-guard, then fix/tool-og-image-own-domain, then back on main. I did not do any of that. Another agent checked out its branch to do its work, which is the correct thing for it to do, and my uncommitted changes came along for the ride because that is how git works.

The first time it bit me, I had staged a set of file deletions, run the gate, and was about to commit. The tree had moved to someone else's feature branch with an unpushed commit. Committing there would have buried my cleanup inside their pull request.

The fix is unglamorous and works completely:

git worktree add /tmp/wt-cleanup main
cp <my files> /tmp/wt-cleanup/
cd /tmp/wt-cleanup && git commit && git push origin main
git worktree remove /tmp/wt-cleanup --force

A second working directory on main, used for the commit, then thrown away. The other agent's checkout is never touched. It costs about thirty seconds, and it is now the only way I push from this repo.

The habit that matters more than the technique: check git branch --show-current and git fetch before every single commit. Not once per session. Every time. The branch that was correct when you started the task is regularly not the branch you are on when you finish it.

Another agent shipped my unfinished work

I built a pricing index page over an afternoon and left it uncommitted while waiting on feedback about the design.

While I was doing something else, another agent found those untracked files, decided the page needed the same header treatment as the rest of the site, wrote a wrapper component, generalized that wrapper to serve a second route as well, and merged the whole thing in pull request #22.

Nothing about that is wrong. The work was better for it. But it is a genuinely strange experience to look for your uncommitted changes and find them already in production, in a component you didn't write.

The lesson is that "uncommitted" is not a signal any agent can read. If work isn't ready to ship, it needs to be on its own branch, not sitting in the tree as an implicit do-not-touch.

Tools collide in ways a single agent never shows you

Some of this is embarrassingly mundane and cost me more time than any of the interesting problems.

That is three Claude Code sessions in one window, each on its own task, all pointed at the same checkout. It looks productive. It is also the exact condition in which the next two problems happen.

npm run verify kills npm run dev. Both own the .next directory. The gate's build wipes the manifest the dev server is reading, and the dev server dies on a missing _buildManifest.js.tmp. Worse, it sometimes survives as a process still bound to the port while serving 500s on every route, so the next thing you check looks catastrophically broken when it is just a corpse holding a socket.

The tell is that every route fails, including ones you didn't touch. When / is throwing 500s and you only changed one component, stop debugging your change:

lsof -ti:3100 | xargs -r kill -9; pkill -9 -f "next dev"; rm -rf .next

With one agent, you notice this once and remember. With several, one agent runs the gate while another reads localhost, and the second agent starts debugging a fault that doesn't exist.

Agents invent shapes that type-check perfectly

Here is the one that reached production.

I needed to write a pricing record into a JSONB column. I knew roughly what it looked like from having read other rows, so I wrote it from memory: a tiers array of objects with name and monthly fields.

The real contract, defined in a TypeScript file one away, uses monthly_usd. JSONB has no schema, so the database accepted it happily. The page component then did this:

const hasAnyPricedTier = tiers.some((t) => t.monthly_usd !== null)

My objects had no monthly_usd at all. undefined !== null is true, so the component decided every tier was priced, tried to format undefined as currency, and threw. The tool page returned 500 for about two minutes until I checked the live URL and reverted.

Nothing caught it. Not the type checker, because the write went through a plain object. Not the build, because the gate points the database at an unreachable address on purpose and prerenders zero tool pages. Only loading the actual page found it.

What I should have done, and now do, is read the interface before writing to the column it describes, and check the shape against existing rows rather than my memory of them. An agent that has seen a hundred JSON objects is extremely confident about what the hundred-and-first looks like.

Parse success is not identity success

Five tools in the directory were showing identical pricing: free, then four dollars, then twenty-one dollars a month. GitHub Copilot was one of them, which is wrong, because Copilot costs ten dollars.

All five were open-source projects whose listings included a GitHub URL. The pricing crawler followed that URL, landed on github.com/pricing, and parsed GitHub's own platform pricing flawlessly. Correct data, wrong company, high confidence, recorded as verified.

It sat there invisibly for weeks because a wrong price on one tool page among hundreds looks like a price. It only became obvious when I aggregated every price onto a single page sorted cheapest first, and five unrelated tools appeared in a block with identical numbers.

The general form: a crawler keys on a URL, and a URL is not an identity. Any automated enrichment step needs a check that the page it parsed is about the thing it thinks it is about.

The guardrails that actually hold

After all of that, the things that work are boring and few.

One command decides whether work is done. npm run verify runs lint, typecheck, a packaged-assets check, and a real production build. It takes about forty seconds. The exit code is the entire rule. No agent hands back work on a red gate, and no agent gets to argue that the failure is unrelated.

The ways around the gate are written down and forbidden by name. This matters more than the gate itself. An agent under pressure to make a check pass is inventive, so the rules are explicit: no eslint-disable comments, no any casts to silence a type error, no @ts-expect-error on the failing line, no deleting the call site, no quietly dropping part of the change so the rest gets through. Writing these down converted a recurring argument into a lookup.

A warning ratchet that only moves one way. The lint baseline is a number in a JSON file, currently 26. New warnings above it fail the gate. Lowering it is fine; raising it requires a stated reason. Without this, warning counts drift one agent upward at a time, and nobody is responsible.

Everything that writes to production is dry run by default. The migration tool reads only, and prints exactly which rows it would write, unless you pass --execute. The media scripts download and quality-gate images into a temp directory and upload nothing unless you use --upload.

Approval is a separate, named step. Generating a migration is not approval to run it. The sequence is generate, validate, dry run, show the output, wait for an explicit yes, then execute. Approval covers one batch and expires with it. This is the rule I would keep if I could only keep one, because it is the difference between an agent that proposes and an agent that acts.

Read results back with the least privileged key you have. After a write, the row gets read again with the anonymous key rather than the service key, because the question is not "did the write succeed" but "can a visitor see this."

What I would tell someone starting

Put the rules where the agents read them. Mine live in a CLAUDE.md at the repo root, and the ones that get followed are the ones written as commands with named forbidden alternatives, not as principles.

Assume the working tree is contended. Check the branch before every commit and use a worktree to push.

Verify content, not metadata. While cleaning up applied migrations, I nearly deleted two as unapplied, because the updated_at column on their rows said January and the migration files said August. Comparing the migration text to the live content showed both had, in fact, run. The timestamp column simply was not maintained on that write path. Timestamps lie; content does not.

And the honest limitation: this repo has no test suite yet. The gate proves the code builds and type-checks. It does not prove the code behaves. Everything above is scaffolding around that gap, and the scaffolding is why several agents can work in one repo without breaking it, not a substitute for tests I still owe myself.

Nobody has figured this out yet

I want to be clear that none of the above is advice from someone who has solved it. Every rule in this post exists because something went wrong first, and I expect half of them to look naive in a year.

Writing code is arguably the solved part now. Across those 66 commits, almost nothing failed because an agent could not write the function. What failed was two agents wanting the same working tree, an agent confidently inventing a data shape, a crawler parsing the right page for the wrong company, and a dev server dying because two processes assumed they owned a directory. Those are coordination problems, and coordination is where the tooling is thinnest.

Humans have decades of accumulated practice working together in one codebase. Version control, code review, CI, branch protection, on-call rotations. All of it assumes participants who get tired, remember yesterday, and ask before doing something irreversible. Agents have none of those properties. They are fast, tireless, extremely confident, and have no memory of what they broke last Tuesday unless you wrote it down somewhere they can read.

So we are all improvising the equivalent layer, in public, right now. Some of what I do will turn out to be the right pattern. More of it will turn out to be a workaround for a gap that gets closed properly. The git worktree dance is almost certainly the second kind. It works, and it is obviously a symptom of tools that assume one operator per checkout.

If you are running more than one agent against real code, you are doing original work whether you meant to or not. Write down what breaks. That is the actual contribution at this stage, and it is worth more than another post about how fast the code got written.

Phind Alternatives: What Developers Actually Use Now

Bojan Tomic — Thu, 03 Sep 2026 20:07:06 +0000

People are still looking for Phind. Not in a nostalgic way, in a "my bookmark stopped working, what do I do now" way.

I know this because I can see it. Phind is still one of the largest sources of search demand reaching this site, months after the shutdown, and its shape has changed. The questions used to be is it gone. Now they are what do I use instead, and "phind alternative" keeps turning up among them.

So this is that post. If you want the story of why Phind died 37 days after raising $10 million, I wrote that in Why Did Phind Shut Down. This one is only about what to move to.

What You Are Actually Replacing

Before listing alternatives, it is worth being precise about what Phind did, because most recommended tools replace only half of it.

Phind was two products stapled together. It was a search engine that read documentation, Stack Overflow, and GitHub issues and answered technical questions with citations. It was also, increasingly, a code generator that would write the fix rather than just point at it. The reason it felt different from asking ChatGPT was the first half: it went and looked things up, and it showed you where the answer came from.

That split matters when you choose a replacement. If what you miss is cited technical search, you want an answer engine. If what you miss is "write this function for me", you want a coding agent, and the market for those has moved a long way since January. Most people miss the first thing and get recommended the second.

One more honest note before the list. I pulled every price below from the vendor's own pricing page rather than copying it from another directory, and each tool page on this site includes the date it was last checked. Prices move. If you are reading this months from now, check the tool page.

Perplexity: The Closest Thing to a Direct Swap

Perplexity is where most Phind users landed, and it is still the honest first recommendation. It is an answer engine with inline citations, which is the specific behavior that made Phind useful.

Free tier; Pro is $20/month. That buys unlimited Pro searches and model choice.

What it does well: citations are genuinely good, and it is fast enough that you will use it instead of opening three Stack Overflow tabs. For "why does this library throw this error", it usually beats a Google search on time to answer.

What you lose: Phind was tuned for developers, and Perplexity is not. Ask it something niche about a build tool, and you will get a mix of real documentation and SEO blog spam, and it does not always know which is which. You end up checking the citations more often than you did with Phind, which is the tax for using a general tool.

Claude: What Most People Mean by "Claude vs Phind"

Enough people search "claude vs phind" that it is worth answering directly.

Claude is not a search engine. It is a reasoning model with web search attached, and that difference shows up in how you use it. Perplexity answers a question. Claude works a problem and searches when it needs to.

Free tier with roughly 50 messages a day. Pro is $20 a month. Claude Code, the terminal agent, is $30 a month.

What it does well: understanding a messy problem you cannot phrase cleanly. If your question is "this build works locally and fails in CI and I do not know why", Claude is better than an answer engine, because the useful output is a line of reasoning rather than a citation.

What you lose: it is slower, and web search is not its strength. For a question with one factual answer in the documentation, an answer engine gets there first. I would not use Claude to look up a flag.

If you are choosing between them: Perplexity for lookups, Claude for problems. Most people who miss Phind actually miss both halves and end up paying for two things, which is worth saying out loud rather than pretending one tool covers it.

Exa: Search Built for Programs, Not People

Exa is the interesting one, and it is not for everybody.

It is a search API designed to be called by code and by agents rather than typed into a box. If your reason for using Phind was that it understood technical queries and returned things you could actually use, and you are comfortable writing a script, Exa gets closer to that than a chat interface does.

Pricing is not a subscription. Starter is free with $20 of credits on signup and $10 every month, and it does not ask for a card. Beyond that it is pay as you go per request: $7 per 1,000 searches, more for deep search and reasoning variants.

What it does well: no monthly commitment, and a free allowance that is enough to find out whether it fits before you spend anything.

What you lose: there is no polished consumer product here. If you want to open a tab and type a question, this is the wrong tool and you should use Perplexity.

The Coding Agents, If That Is the Half You Miss

If what you actually used Phind for was generating code rather than finding answers, the honest advice is that this category has changed more than the search one, and you have better options now than you did in January.

Cursor is the mainstream choice: an AI-first editor built on VS Code, free tier with 2,000 completions a month, Pro at $20 with a credit pool, Ultra at $200.

Cline is the open-source counterargument. Apache-2.0, no subscription and no seat fee, and you pay only for model inference with your own API key. The running cost is yours to see rather than a flat charge you forget about, which some people prefer, and others hate.

Continue.dev sits between them: open source and working in both VS Code and JetBrains, which matters if your team isn't all on the same editor.

I would not call any of these a Phind replacement. They're different tools for different parts of the job, and pretending otherwise is how people end up disappointed.

What I Would Not Recommend

A few things get suggested in these threads that I think are wrong.

Going back to plain Google is advice people give because it sounds hard-nosed. It is free and comprehensive, and there is no hallucination risk. It is also slower for the exact queries Phind was good at, and the results for programming questions have gotten noticeably worse. It is a fallback, not a plan.

ChatGPT with search gets recommended constantly and it is fine, but if you are choosing fresh rather than already paying for it, Perplexity does the search half better for the same $20.

And a general warning about this category: You.com still appears on alternative lists as a consumer search product, but it now sells API access only, with no consumer subscription publicly on sale. That is the sort of thing an alternatives roundup gets wrong when it is assembled from other roundups instead of from the vendors' own pages.

What I Would Actually Do

If you want one thing: Perplexity, $20, and accept that it is less developer-focused than what you lost.

If you want the setup that most closely reconstructs Phind: Perplexity for lookups and Claude for problems. That is $40 a month, which is more than Phind cost, and I understand if that is where you stop reading.

If you are cost-sensitive or building something: Exa's free tier costs nothing and asks for no card, and Cline is free except for inference. That combination gets you a long way for the price of the tokens you burn.

The uncomfortable truth is that nothing on this list is Phind. Phind's advantage was being one product that did both halves for developers specifically, and nobody has rebuilt that, which is likely why it couldn't stay in business. The alternatives are all either broader and shallower or narrower and deeper.

If you want to see what else has landed in this category, the AI search tools in the directory all carry prices checked against the vendor's own page, with the date on each one. And if you are curious how a similar story played out for a coding tool rather than a search one, what happened to Codeium covers a product that did not shut down so much as become something else.

I keep the tool listings and their prices up to date at intelligenttools.co, with each listing showing the date the price was last checked against the vendor's own page.

Context anchoring works. Files, not a service.

Bojan Tomic — Wed, 02 Sep 2026 11:49:54 +0000

I used to keep AI chat sessions open far longer than made sense, because closing one meant re-explaining my project from scratch. Rahul Garg has a name for the fix: context anchoring, "the practice of making that alignment durable." It went up on martinfowler.com and it is worth your ten minutes.

His test for whether you have got it right is the part that stuck with me:

If I can close my chat session and start a new one without anxiety, my context is properly anchored.

That reframed the problem for me. I had been treating the long session as the asset. It is the symptom.

Files, not a service

Once you accept that context should live outside the conversation, you have to decide where. There is a whole category of hosted "AI memory" products that will answer this for you, and I went and benchmarked one properly this week before deciding.

I would rather anchor to markdown files in the repo:

Works offline. No account, no backend, no outage.
Diffs in review. A teammate can argue with a decision record in a PR. You cannot review a vector store.
Survives the vendor. I maintain an AI tools directory, and I have spent this month correcting listings for products that got acquired and wound down. Betting your project's memory on a seed-stage startup is a real risk, not a theoretical one.

Sync is a fine optional layer. It should not be the substrate.

The number that settled it

I measured both approaches on the same machine.

	Tokens per request
File-based memory: a one-line index, 15 entries	579
Hosted memory MCP: 27 tool schemas, 0 entries stored	8,866

The hosted service costs roughly 15x more per request, before it has remembered anything at all. The reason is architectural. MCP tool definitions ship on every single request whether you call them or not, so a broad tool surface is a permanent tax. A file-based index loads one line per memory and fetches the body only when it looks relevant.

Same idea. An order of magnitude apart in cost, purely from where you put the state.

The part I would add: anchors rot

Garg scopes his advice carefully, and the article is about capturing decisions while they are fresh. Here is what I hit after doing this for a while.

Yesterday I wrote a memory saying an automated check "does not exist yet and is worth building." Today I built it. The memory was now confidently, specifically wrong, and nothing flagged it. It would have kept telling future sessions to build a thing that already existed.

Anchored context decays exactly like documentation, except an AI reads it with more trust than a human would and acts on it. A decision record that names a function deleted last month gets asserted, not questioned.

So my working rule: every anchor carries the date and the reason, and anything naming a file, function or flag gets verified against the repo before I act on it. Writing the anchor is the easy half. Keeping it honest is the actual work, and I have not seen anyone solve it properly yet.

If you are already doing this, I would like to know how you handle staleness. That is the open problem.

What Happened to Codeium? From Windsurf to Devin Desktop

Bojan Tomic — Fri, 28 Aug 2026 20:12:55 +0000

Type codeium.com into a browser today and you will not land on Codeium.

You get a 301 to windsurf.com, which throws a 308 to devin.ai/desktop. Two redirects, three brand names, one product. I only noticed because Codeium had quietly become the biggest single traffic source on this site, and when I went to check that our listing was still accurate, the destination had moved twice.

If you are reading this because your extension renamed itself, or because a tutorial from last year pointed you at a domain that no longer exists, here is the whole chain in one place.

The Three-Name Timeline

Codeium did not shut down. That is the first thing worth saying, because the redirect chain makes it feel like it did, and that is not the same story as Phind, which genuinely went dark with two weeks notice.

What happened instead was two rebrands wrapped around an acquisition:

2022: Launched as Codeium by Varun Mohan and Douglas Chen, free AI autocomplete for individuals
Late 2024: Rebranded to Windsurf, pivoting from an extension to a full agentic IDE
July 2025: Cognition AI acquired Windsurf's IP, brand, and remaining team
June 2, 2026: Windsurf renamed to Devin Desktop, shipped as an over-the-air update
July 1, 2026: Cascade, the original in-editor agent, reached end of life

The June rebrand had no migration wizard and no reinstall. Existing installs updated themselves and kept plans and settings intact. That is the good version of this kind of transition, and it is worth acknowledging before I get to the parts that are less good.

What Actually Changed for You

The naming is the confusing part, so here is the mapping as I understand it.

The old Codeium extension is now the Tab completions feature inside Devin. The Windsurf IDE is now Devin Desktop. Cascade, the agent you may have been using inside Windsurf, is gone as of July 1 and Devin Local replaced it as the default local agent. Cognition now ships one product family (Devin Cloud, Devin Desktop, Devin Review) where there used to be two separate brands.

Read that headline again if you started on Codeium: "Manage fleets of local and cloud agents from one surface." That is the same lineage as a free autocomplete extension, four years and three names later. The screenshot is not a gotcha, it is just the clearest single statement of where this product went.

There is still a free tier, and the detail that matters most to old Codeium users is that it kept the thing Codeium was for. Here is the current ladder, from Cognition's own pricing page:

Plan	Price	What you get
Free	$0	Unlimited Tab completions, unlimited inline edits, light agent quota, limited model availability
Pro	$20/month	Full model availability including OpenAI, Claude and Gemini frontier models, free use of SWE 1.7, cloud agents (Devin Cloud), extra usage at API pricing
Max	$200/month	Everything in Pro with significantly higher quotas
Teams	$80/month + $40 per dev seat	Unlimited members, centralised billing, admin dashboard, priority support
Enterprise	Contact	SAML/OIDC SSO, enterprise admin controls, dedicated deployment

Note the Teams line, because it is easy to misread: it is an $80 monthly platform fee plus $40 per full developer seat, not $40 a seat flat. A five-developer team is $280 a month, not $200.

Existing Windsurf subscribers kept their original plan pricing through the rename.

The Part That Should Bother You

Codeium's original pitch was "free forever for individuals." That was the whole reason it built the user base it did. It was the tool you recommended to a junior who could not expense $20 a month, and the one you put on a personal machine where a Copilot seat made no sense.

Three brand names later, that product is a completion tier inside an enterprise agent platform. To be fair where fairness is due: unlimited Tab completions and unlimited inline edits are still free, so the specific promise Codeium made to individuals is intact. This is not a bait and switch and I am not going to call it one.

What changed is everything around it. The free tier now says "limited model availability" and "light quota to code with agents," so the good models and the agentic work are the upsell. The centre of gravity moved from "free autocomplete for individuals" to "fleets of coding agents for engineering orgs," and the ladder reflects it: a $200 Max tier and an $80-plus-per-seat Teams plan are not aimed at the person Codeium was originally built for. You can still stand on the free tier. You are just no longer the customer.

Devin Review is the clearest illustration of the new shape. Organised diffs, moved-code detection, vulnerability flagging on every pull request: this is a product sold to engineering organisations with review processes, not to the individual who installed Codeium because autocomplete was free. Nothing wrong with that product. It is just a different buyer.

Cascade reaching end of life is the concrete loss. If you had workflows built on it, they did not survive the transition, and no amount of automatic updating fixes a removed feature.

The Broader Pattern

This is the third acquisition in this exact corner of the market, and the pattern is getting hard to ignore.

Cursor acquired Supermaven in November 2024. Supermaven was one of the genuinely good standalone completion engines, fast in a way that made Copilot feel sluggish. Anysphere refunded active subscribers in November 2025 and wound the standalone product down. JetBrains and Neovim users kept legacy access; VS Code users got nothing and were told to move to Cursor. Cursor has since also acquired Continue.

So of the five tools you would have listed as "Codeium alternatives" eighteen months ago, two have been absorbed into other products and one has been renamed twice.

If you are picking an AI completion tool in 2026, acquisition risk is a real selection criterion, not a hypothetical. The question is not just whether the tool is good. It is what happens to your workflow when the company is bought, because in this market it probably will be.

What to Use Instead

I am not going to pretend I have run all of these in anger for six months. What I can tell you is what each one is actually for, and which ones are structurally resistant to the problem above.

If you want to just stay put: Devin Desktop is a reasonable tool and the free tier still gives you unlimited Tab completions, which is the part you were probably using anyway. Doing nothing is a legitimate choice, and the automatic migration means you may already be using it without having decided to. You also picked up capability you did not have under Codeium, including a terminal agent that installs with one curl command.

If you want the closest thing to old Codeium: Tabnine at $12 a user is the surviving privacy-focused completion tool with a free tier, and it has stayed a completion tool rather than reinventing itself as an agent platform every eighteen months.

If you want the mainstream default: GitHub Copilot at $10 a month for individuals, free for students. It is owned by Microsoft, which is the one thing on this list nobody is going to acquire.

If you want the full agentic IDE: Cursor is where most of the Windsurf audience went. Free Hobby tier with 2,000 completions a month, Pro at $20. Note the irony that Cursor is the company doing the acquiring in this story.

If acquisition risk is what you actually care about: this is where open source stops being an ideological preference and starts being a practical hedge. Cline is Apache-2.0 with no seat fee, and you bring your own model key. Continue is open source and runs in your existing editor. Zed has a free tier with the full editor and meters AI by token rather than charging a flat assistant fee. A company can be acquired; an MIT-licensed repo on your disk cannot be renamed out from under you.

If you are on AWS anyway: Amazon CodeWhisperer is now Amazon Q Developer, which is its own small lesson in this article's theme. Free for individual use.

If you want code search rather than completion: Sourcegraph Cody at $9 a user, with a free tier.

What I Would Actually Do

If you were a happy Codeium free-tier user and you have not noticed anything break, do nothing. The rename is cosmetic from where you sit, and churning tools costs more than it saves.

If you were on Cascade, you have already had to move and you should treat that as a signal about how much of your workflow you want living inside a single vendor's agent product.

If you are choosing fresh, I would weight two things more heavily than I did two years ago. First, does this tool do one thing rather than pivoting annually into whatever the market rewards this quarter. Second, if the company is bought tomorrow, what do I keep. Those two questions would have steered you away from Codeium and Supermaven and toward Copilot, Tabnine, or something open source, which is roughly how the last two years actually played out.

The honest summary is that Codeium did not fail. It succeeded hard enough to get bought, and the thing that made it worth using to individual developers was not the thing that made it worth buying.

I will update this post when I have spent real time in Devin Desktop rather than just tracing its redirects.

Originally published at intelligenttools.co.

I Gave My Coding Agents a Task Board: Setting Up Multica

Bojan Tomic — Wed, 26 Aug 2026 20:34:34 +0000

Running one coding agent is fine. You open a terminal, describe the job, watch it work.

Running three is where it falls apart. Each one lives in its own terminal; none of them knows what the others did, and the only record of what happened is scrollback you will close by accident. There is no answer to "what is in flight right now" other than checking four windows.

Multica is a task board for that problem. Agents get assigned issues the same way people do, they move their own cards across the board, and their work is attached to the issue instead of living in a terminal you closed.

This is what setting it up on a real project looked like: this site, its actual backlog, three agents, and what the first few hours actually consumed.

Setup: 20 minutes, no errors

I used the desktop app on macOS rather than self-hosting, which is the fastest route.

The only step that needs a decision is authentication. Log in to GitHub from your terminal over HTTPS before you start, because that is the credential the agents use when they open pull requests. Get that wrong, and everything works right up until the moment an agent tries to push, which is the worst place to discover it.

That was the whole setup. Download, sign in, connect the repository, done in about twenty minutes with nothing going wrong.

One thing that catches people out: Multica does not ship an agent. It drives the CLIs you already have. A daemon scans the machine for tools it recognizes and registers a runtime for each. It supports 23 out of the box, including Claude Code, Codex, Cursor, Copilot, OpenCode, OpenClaw, Gemini CLI, and Kimi. Mine runs on Claude Code on the MacBook. If you have no agent CLI installed, install one first.

Creating agents by asking for them

I expected a form. There is one, but it is not how you are meant to work.

Multica ships with an agent called Mika, described as a workspace chief of staff, and you create everything else by talking to it. You describe the job you want done in plain language and Mika creates the issue, the agent, or the schedule. The dialog literally prompts you with an example: "let Bojan fix the inbox loading slowness in the Web project".

Both of my other agents came out of that chat:

Agent	Job	Access
Mika	Chief of staff. Turns goals into issues, coordinates the others, builds reusable workflows	Workspace
Vera	Reviews agent-authored pull requests with fresh context	Owner only
Scout	Finds AI tools worth adding to the directory and verifies them	Workspace

The narrowness matters. An agent told to "help with the site" produces vague work. An agent told "review agent-authored PRs, and you did not write this code" produces something usable.

So does the access column. Vera is owner only, because a reviewer anyone can retask is not a reviewer.

Instructions are plain text in the agent's Instructions tab. Edit them and behavior changes on the next run; no redeploy. You are tuning a job description, not a config file.

Writing issues agents can actually finish

The board is an ordinary kanban: Backlog, Todo, In Progress, In Review, Done. Agents move their own cards. When Vera finished a review, she moved the issue to In Review herself and left the write-up as a comment.

What made this work was writing issues with an Outcome line instead of a task line. "Define the verify gate agents must pass before hand-back" is a task. "A named, runnable verify gate" is an outcome. Agents handle the second far better, because there is something concrete to check themselves against.

Some real ones off my board:

Connect the codebase to the project
Define the verify gate agents must pass before hand-back
Automated code review pass on agent PRs
Backlog sweep: turn existing TODOs and known issues into issues
Repeatable CLI triage for pending tool submissions

The part that matters: making them stop

This is the piece I would keep if I threw the rest away.

Scout runs on a schedule through Autopilot: a cron trigger at 17:00 daily, which creates an issue in a dedicated project and assigns it to Scout. The instructions are explicit about where it must stop, and that is most of the prompt:

Run one Phase 1 scouting cycle. Phase 1 only, report and stop.

Check out the repository and re-read CLAUDE.md before anything else, in particular the CRITICAL SAFETY RULES. Do not work from memory of these files.

Then STOP. Do not write SQL, open a PR, or touch the database. Set the issue status to in_review and wait.

Everything before "STOP" is read-only: sweep for candidates, deduplicate against what is already listed and anything already staged, verify each survivor by loading its own website and pricing page in a headless browser, and post the findings as a comment. Nothing is written anywhere.

I read that comment and reply naming which ones to add. That reply is what unblocks Phase 2, where it writes the migration, runs the validation scripts, and opens a pull request. Applying the migration to the live database stays my job, explicitly: "Applying it to the live database is his action, never yours."

Three stops, each waiting on a human. Silence keeps it stopped indefinitely, because there is no timeout that quietly approves for you.

That design came from a specific worry. One script in this repo writes to the production database unless you pass --dry-run, and I don't want an unattended agent editing a directory with 400+ tools.

Two smaller instructions in there earn their place too. "Never treat aggregator or roundup pricing as evidence", because that is exactly how a wrong price ends up copied across the whole internet. And "Do not pad the batch to reach a number; that is a worse outcome than a short report", because otherwise you get five results whether or not five exist.

If you take one thing from this post: decide what an agent may do without asking, and make everything else stop and wait.

What it actually consumed

Multica has an Analytics tab. This is the first few hours of use, not a month, though the dashboard window says 30 days because that is all the history there is:

	First few hours
Estimated cost	$23.43
Tasks	20, none failed
Run time	1h 15m

Read that number carefully, because it is not a bill. My runtime is Claude Code on a $ 100-a-month plan I already pay for, so nothing here appeared as an extra charge. The $23.43 is Multica's estimate of what that usage would have cost at API rates, which makes it a useful measure of how much work you got through, not money that left my account.

Split by agent, Mika did 19 tasks for an estimated $21.31 and just over an hour of run time. Vera did a single code review for $2.12 and 9.5 minutes.

The comparison worth drawing is against your plan, not against a bill. Twenty tasks in an afternoon consumed roughly a quarter of a month's allowance at API-equivalent rates. If you already pay for a coding agent subscription, that is the frame. Agents on a board burn your existing allowance faster than you typing at one of them does, and the analytics tab is where you find that out before your limits do.

Is the output any good

Here is Vera reviewing a pull request another agent wrote:

The blocking finding is the only one I'd defend without qualification, and I only have it because I ran the gate instead of reading it. No amount of staring at "eslintWarnings": 27 tells you the true count is 25; you have to execute it.

Then, unprompted:

The two I'm least sure about are the two I'd have produced from the diff alone. #1 (unenforced prohibitions) is an argument, not an observation... Both are the kind of finding a reviewer generates to look thorough, which is precisely why I'm flagging them as the suspect ones.

An agent separating what it verified from what it inferred, and telling me which half to distrust, is more useful than a longer list of findings.

I am not going to pretend every run looks like that. A backlog sweep the same afternoon canceled a dozen issues, which was correct but not exactly craftsmanship. The point is that good output is legible and bad output is visible, because it all lands on the issue rather than in a terminal.

The CLI

Everything on the board has a command-line equivalent, which matters if you want to script around it:

multica agent get <agent-id> --output json
multica autopilot get <autopilot-id> --output json
multica autopilot runs <autopilot-id> --output json

autopilot runs is the one I reach for: it is the run history for a scheduled agent, so it answers "did it fire last night and what did it do" without opening the app.

License and pricing, before you build on it

Self-hosting is free with no caps on agent count. Concurrency is limited by your hardware, and you can join multiple machines as runtimes.

Two things the marketing does not lead with.

The licence is not plain open source. It is Apache 2.0 with additional conditions: you may not offer Multica as a hosted service to third parties without a commercial license, even if you charge nothing. You may not remove the branding without a written waiver. Internal use inside one organization is explicitly fine, which covers most people reading this.

There is no published cloud pricing. The hosted version offers a free trial, and multica.ai/pricing returns a 404.

Would I keep it

Yes, with a caveat: the value is not the agents; it is the board and the gates.

The agents already existed. What changed is that I can see what they are doing, the work survives the session, and nothing irreversible happens without me saying so. That last part is what makes it usable on a live site rather than a toy repo.

Honest status: the scheduled scouting run is configured and has not fired yet, so I can tell you the design is right but not yet that it survives contact with a month of daily runs. I will report back when it has.

If you run one agent occasionally, this is a coordination layer for a problem you do not have yet. If you have three terminals open and no idea what is finished, it is the missing piece.

Originally published at intelligenttools.co, where I keep a directory of AI tools with prices checked on the vendor's own page.

I guess when you start using a harness and a model, it's difficult to change. But what would you suggest using for coding, in your experience?

Bojan Tomic — Fri, 21 Aug 2026 12:45:31 +0000

Best Namelix Alternatives for AI Logo Design in 2026

Bojan Tomic — Thu, 20 Aug 2026 13:56:43 +0000

Originally published on Intelligent Tools.

Namelix is genuinely good at the thing it was built for. You describe your idea, and it returns short, brandable coinages; unlike the keyword-mashup generators it competes with, the names actually sound like companies. It is free, filters by length, keyword, and domain extension, and learns from the names you save. If you need a name, start there.

The problem is what happens next.

Where Namelix Falls Short in 2026

The logo is a preview, not a product. Brandmark.io makes Namelix, and the polished logo beside every generated name is the top of a funnel. It looks like you are getting a name and a logo. You are getting a name and an advertisement. To download anything usable, you leave for Brandmark and pay.

Most of the good names are gone. Namelix has been running for years, similar prompts produce overlapping results, and every other founder in your category has typed roughly the same description into it. The names that feel most obviously right are the ones most likely to be taken.

Domain availability is worse than it has ever been. The generator will happily hand you a beautiful five-letter name whose .com sold for five figures in 2019. Namelix surfaces domain options, but the hit rate on an available .com for a genuinely good short name in 2026 is low enough that most people end up on a .co, .io, or .ai.

Volume beats quality by design. You get pages of names and scrolling is the interface. That works when you want to be surprised and badly when you want to decide.

None of that makes Namelix bad. It makes it a naming tool that stops one step short of what you came for. Here are the tools that cover the rest.

Looka: The Default Namelix Alternative

Looka is the tool most people land on after Namelix, and this comparison is why this post exists. Where Namelix ends at a name, Looka starts at one. You give it your company name and industry, pick styles and colors you like, and it generates full logo concepts you can edit in the browser.

What it does well: the editor is the strongest part. You can change fonts, spacing, color, layout, and icons, and the output still holds together afterward, which is not true of every tool here. The Brand Kit extends one logo into business cards, social templates, and brand guidelines.

Pricing: designing is free and unlimited. Downloading is not. The Basic package is a one-time $20 for a single PNG. Premium is a one-time $65 and is the one worth buying, because it includes vector files (SVG and EPS), multiple color variations, and full ownership. Brand Kit runs $96/year, and Brand Kit Web at $129/year adds an AI website generator.

Namelix vs Looka: not really competitors, but two halves of one job. Namelix gives you a name for free. Looka turns it into a logo you own for $65. The catch is the free-to-design, pay-to-download model: you invest an hour in the editor before finding out you care enough to pay. That is deliberate, and it works.

Brandmark: Namelix's Own Paid Half

Brandmark is where Namelix sends you, so it is worth evaluating on its merits rather than treating it as an upsell.

What it does well: output quality is a step above the template-driven tools, and the pricing is the most honest here. You pay once and keep access, with full copyright and unlimited revisions. No subscription quietly renewing next year.

Pricing: Basic is $35 one-time for PNG and vector files. Designer is $95 one-time and adds source files, brand guidelines, a one-page website, business card, and social designs. Enterprise is $195 one-time and includes up to 10 hand-crafted concepts plus font downloads.

Namelix vs Brandmark: this is the intended path and a reasonable one. If you already like the preview Namelix showed you, Brandmark is the shortest route to owning it. It is not my first recommendation on price-to-flexibility: $95 for the tier most people need beats Looka's $65 Premium, and Looka's editor gives you more room afterward.

Canva: Best AI Logo Maker If You Already Design

Canva is not a logo generator. It is a design platform with a logo maker, and that distinction decides whether it is right for you.

What it does well: everything after the logo. Your logo lives in the same workspace as your pitch deck, social posts, invoices, and thumbnails, with brand colors and fonts applied consistently. No other tool here touches that. AI generation is competent rather than remarkable, but the template library is enormous.

Pricing: the free tier is genuinely usable and lets you make and download a logo. Pro is roughly $15 to $18 per month depending on region and billing period, and Business runs about $25 per user per month. Check the current number before you buy, because Canva's regional pricing moves.

Namelix vs Canva: Canva will not name your company, and its logo output is more assembled than designed. What it gives you instead is the other forty things you need in month one. For a solo founder already making their own social graphics, the Pro subscription does far more work than a one-time logo purchase.

One caveat worth knowing: logos built from Canva's stock elements carry usage restrictions and generally cannot be trademarked. If you plan to register the mark, read the license terms first or use a tool that grants full copyright.

Tailor Brands: When the Logo Is Not Really the Point

Tailor Brands has quietly stopped being a logo company. It is now an LLC formation service that includes a logo maker, and its pricing reflects that.

What it does well: it handles company registration, operating agreements, annual compliance, a domain, a website, and the logo in one flow. At the "I need to actually exist as a business" stage, that bundle removes real work.

Pricing: Lite is $0 plus state fees and includes 8 logos, a domain, a website, and business card tools. Essential is $199/year plus state fees and adds accelerated processing and legal compliance. Elite is $249/year plus state fees.

Namelix vs Tailor Brands: barely comparable. Namelix is a free naming tool; Tailor Brands is a business formation service with branding attached. Judged purely as an AI logo generator, it is the weakest here, and the logos are visibly template-driven. Judged as a way to go from idea to registered company in an afternoon, the logo is a bonus.

Kittl: For People Who Can Actually Draw

Kittl is the outlier here, and the one I would point a designer toward.

What it does well: it is a real design tool with serious typography, vintage and hand-lettered styles, and effects that the generator-driven tools cannot produce. Logos out of Kittl look made rather than assembled. The AI features are token-metered rather than unlimited.

Pricing: a free tier gives 200 one-time AI tokens. Pro is $15/month, or $12/month billed annually, with 2,000 AI tokens per month per editor. Expert is $35/month ($26 annually) with 12,000 tokens, and Max is $65/month ($48 annually).

Namelix vs Kittl: opposite philosophies. Namelix removes every decision; Kittl hands them all back. If you have design skills and want output that looks like a person made it, this is the best tool here. If you want a logo in ten minutes with no opinions about kerning, it is the wrong one.

Logo Diffusion: The Actual AI Logo Generator

Logo Diffusion is the only tool here that does image-model generation rather than template assembly, which makes it the most interesting and least predictable.

What it does well: you can generate from a text prompt, a rough sketch, or an existing image, a workflow none of the others offer. Sketch-to-logo genuinely works. It includes a vectorizer, background remover, upscaling, and editing models.

Pricing: a free tier gives 24 credits, roughly 12 logos, with no commercial rights or vector export. Basic is $24/month for 1,000 credits. Pro is $49/month for 2,500 credits and adds concurrent generation and upscales. Elite is $99/month. There is also a $15 one-time Starter Pack with 300 credits and three exports, which is the sensible way to trial it. Annual billing takes 20% off.

Namelix vs Logo Diffusion: the closest thing to Namelix in spirit; both generate volume and let you fish. Expect the same trade-off, with some genuinely original results, plenty of unusable ones, and the occasional mangled letterform image models still produce. Subscription pricing is the drawback for a one-off logo, which is what the Starter Pack solves.

Design.com: Fast, With a Pricing Asterisk

Design.com is an AI logo maker wrapped in a wider design platform covering business cards, letterheads, social templates, and a website builder.

What it does well: speed. Name in, usable concepts out, minimal decisions. The asset range is respectable for its tier.

Pricing: this is the caveat. Design.com does not publish a pricing page. It advertises free logos and free business cards, but it doesn't disclose the cost of downloading production files until you are inside the flow. Every other tool here tells you the price up front.

Namelix vs Design.com: similar generate-and-browse experience with more finished output. I would reach for Looka or Brandmark first, purely because I know what they cost upfront.

Two More Namelix Alternatives

Shopify Business Name Generator is free and competes with Namelix directly rather than with the logo tools. Output is more literal and less brandable, but it checks domain availability inline, the exact friction Namelix leaves you with.

Hatchful, also from Shopify, is a free logo maker producing social and branding asset packs. Quality is template-obvious, and customization is limited, but for a side project you are testing for a month, free is the correct price.

Comparison Table

Tool	Best for	Pricing	Own the files?
Namelix	Naming only	Free	No logo files
Looka	Most people	$20 or $65 one-time, $96/yr kit	Yes, on Premium
Brandmark	Buy once, keep forever	$35 / $95 / $195 one-time	Yes, full copyright
Canva	Founders doing their own design	Free, Pro approx $15-18/mo	Restricted license
Tailor Brands	Forming the company too	$0-$249/yr plus state fees	Yes, on paid tiers
Kittl	Designers	Free, $12-$15/mo Pro	Yes
Logo Diffusion	Sketch-to-logo, novelty	$15 one-time or $24-$99/mo	Paid tiers only
Design.com	Speed	Not published	Unclear until checkout

Which One Should You Actually Use

If you need a name: stay on Namelix, and check availability on Shopify's generator or a registrar before you fall in love with anything.

If you need one logo and want to stop thinking about it: Looka Premium at $65. Vector files, color variations, full ownership, one payment. The default answer for most people here.

If you hate subscriptions: Brandmark Designer at $95 one-time. Pricier than Looka, but you own it, and there is nothing to cancel.

If you will be making your own marketing anyway: Canva Pro, treating the logo as one output of a tool you were paying for regardless. Check the trademark limitations first.

If you can design: Kittl. Nothing else here will produce work that looks handmade.

If you are registering a company this week: Tailor Brands, accepting that the logo is the least impressive part of a bundle doing more valuable work elsewhere.

The uncomfortable summary is that the best AI logo maker in 2026 still only gets you to 80% of a competent mark, and the last 20% is either a designer or your own taste. What has improved is the price of that 80%. A one-time $65 for vector files you own is a reasonable trade for a business with no brand budget yet.

The AI Bubble Looks Exactly Like January 2000

Bojan Tomic — Thu, 19 Feb 2026 10:56:07 +0000

Super Bowl LX just happened. Nearly a quarter of the ads were for AI companies. OpenAI, Anthropic, Google, Amazon, Meta—all spending $8-10 million per 30-second spot.

Companies that burn billions in losses pay millions to tell you their products are revolutionary.

I've seen this before. So have you, if you were coding in 2000.

The Dot-Com Parallel Nobody's Talking About

January 2000: A leaked essay called "bubble.com" warned that internet companies were catastrophically overvalued. Nobody listened. Two months later, the market peaked and then lost 75% of its value over 18 months.

Super Bowl XXXIV (January 30, 2000) was packed with dot-com ads. Pets.com with the sock puppet. E*Trade. Seventeen different internet startups are burning venture capital on advertising.

Pets.com had its IPO eleven days after the Super Bowl. The company shut down nine months later.

The Numbers Don't Make Sense

OpenAI is reportedly discussing a funding round that would value it at $830 billion—more than Coca-Cola, Chevron, or Costco.

The company projects:

$14 billion in losses for 2026
$115 billion in cumulative losses through 2029
$20 billion in revenue against $1.4 trillion in compute commitments

That's 1.4% of commitments covered by revenue.

HSBC analysis: Even if OpenAI hits $200 billion in revenue by 2030, they'll still need an additional $207 billion in funding to stay in business.

Microsoft lost $440 billion in market capitalization in a single day after investors questioned its AI spending plans.

The Debt Bubble Under the AI Bubble

Companies supplying infrastructure to OpenAI have taken on $96 billion in debt to fund operations. The big five tech companies (Amazon, Google, Meta, Microsoft, Oracle) added $121 billion in new debt in 2025 alone—four times their historical average.

Oracle is being sued by bondholders for concealing the amount of debt they'd need for an AI buildout. Their credit rating is approaching junk status.

This is exactly how bubbles work: companies with unproven business models borrow unsustainable amounts, then spend desperately on advertising to create the appearance of legitimacy.

The Tools Aren't Going Away

I use Claude Code daily. AI coding assistants are genuinely useful when used correctly. But they're tools that require human judgment, not replacements for it.

The valuable tools will survive the crash. The rest won't. Companies that burn billions while losing money won't make it. The ones with sustainable unit economics might.

What This Means for Developers

Short term: Keep using AI tools while they're heavily subsidized. Learn what works and what doesn't. Build things you couldn't build before because the tedium was too high.

Long term: The opportunities after the crash are probably more interesting than what we're working on now. The dot-com crash gave us Google, Amazon, and modern web development. The AI crash will leave us with whatever actually works.

The code still needs to be written. The bugs still need to be found. The architecture still needs human judgment.

That's not changing, regardless of how many AI companies burn through their funding. That said, I am writing this article in a blog pair-programmed with Claude. Grammarly checked it and offered suggestions. AI is everywhere, and it can't be stopped, no matter the economy.

And yeah, the image is also AI 😄

Originally published at intelligenttools.co

I Let Claude Code Run Unsupervised for 8 Hours - Here's What It Built

Bojan Tomic — Fri, 16 Jan 2026 22:19:27 +0000

Last week, I discovered the Ralph Wiggum technique for Claude Code. Named after the perpetually confused Simpsons character, it lets Claude iterate on code autonomously until tests pass.

I gave it a real production task: refactor our healthcare app's authentication module (8 files, 1,200 lines, JWT handling, session management, password reset).

Started: 11 PM Friday

Woke up: 7 AM Saturday

Result: 47 commits, auth module fully refactored, test coverage improved from 62% to 87%

Cost: $23.14 in API credits

Time saved: 6-8 hours of my weekend

The Setup

claude
> /plugin install ralph-loop@claude-plugins-official
> /ralph-loop "Refactor auth module. Extract business logic from controllers. 
   Max 20 lines per function. Coverage 80%+. All tests must pass."
   --max-iterations 100

Then I went to sleep.

What Actually Happened

Claude ran 47 iterations, each one:

Making changes
Running tests
Reading failures
Adjusting approach
Trying again

When tests finally passed at iteration 47, it stopped with <promise>COMPLETE</promise>.

The Real Results

Worked:

Business logic cleanly separated from controllers
All 8 files refactored systematically
Test coverage jumped to 87%
Zero TypeScript errors
Clean, consistent commit messages

Didn't work:

Still had to review everything (found 2 edge cases it missed)
Cost analysis wasn't perfect ($23 vs my estimate of $15)
Some function names were... creative

The Prompt Makes Everything

My first attempt with a vague prompt ran for 30 iterations and produced garbage.

What worked:

Clear success criteria (tests pass, coverage %, linting)
Explicit constraints (max line length, style rules)
Step-by-step process
Definitive exit condition

What didn't:

"Make it better"
"Improve code quality"
Subjective goals with no metrics

When to Use This (and When Not To)

Perfect for:

Refactoring with good test coverage
Adding tests to untested code
Bug fixes with failing tests
Code cleanup tasks

Don't use for:

Anything without tests (Ralph has no feedback)
Security-critical code (needs human review at each step)
Subjective work (UI design, naming, documentation)
Production data (run in isolated dev environments only)

The Bottom Line

This isn't AGI. It's an extremely capable pattern matcher with good self-correction when tests provide clear feedback.

For healthcare software with HIPAA requirements, I'm keeping autonomous loops in dev environments only. But for the right tasks? It's like having a junior developer who works 24/7 for $20/day.

Full writeup with detailed breakdown, failures, lessons learned, and exact prompts:

👉 Read the complete article on intelligenttools.co

Questions:

Have you tried autonomous coding loops?
What's your experience with Claude Code or similar tools?
What guardrails would you add to this approach?

Drop your thoughts below - genuinely curious how others approach this.

AI Coding in 2026: 10 Predictions

Bojan Tomic — Fri, 26 Dec 2025 11:38:46 +0000

I spent 18 months testing AI coding tools in production and analyzed Stack Overflow's 2025 AI Developer Survey (71,000+ developers, 76% now using AI for code generation).

After testing Claude Code, Cursor, GitHub Copilot, and 17 other tools on genuine healthcare software, here are my predictions for what actually happens in 2026.

Some of these will make you uncomfortable. Good.

🚨 Junior devs stop writing boilerplate entirely

By late 2026, companies will test for "AI collaboration skills" instead of syntax memorization. Interview questions shift from "Write a function to sort an array" to "How would you prompt Claude to build this feature?"

The more established your tech stack, the faster this hits. I'm already seeing it with Node.js/TypeScript.

💰 The "AI-First Developer" becomes a job category

New role: 80% directing AI agents, 20% writing critical logic. Salary range: $120k-180k. One AI-first developer replaces 3-4 traditional juniors on greenfield projects.

This isn't about replacing developers. It's about creating force multipliers who know how to orchestrate AI tools while maintaining code quality.

🔐 First major security breach from AI-generated code

A high-profile incident stems from AI-generated code with a subtle vulnerability. Trust in AI tools drops from 44% to sub-30% for 2-3 months before recovering with better tooling.

This is inevitable. AI tools generate millions of lines of code daily. Eventually, one will cause a significant incident.

💸 Pricing flips from subscription to usage-based

Cursor's $20/month unlimited becomes unsustainable as compute costs surge. By mid-2026, most tools switch to $0.02-0.05 per request. Power users generating entire backends pay $300+/month.

The economics don't work for flat-rate unlimited access when some users generate 100x more tokens than others.

Read All 10 Predictions

I've shared 4 of 10 predictions here. The complete analysis includes:

Why Claude Code captures 30% of the CLI-based market
MCP Protocol becoming the connector standard (5,000+ servers by Q4)
Tool fragmentation by developer specialty (frontend vs backend vs DevOps)
Open-source AI tools reaching feature parity
First AI coding tool IPO (Cursor at $5B+ or Copilot spins out)
Prompt engineering is becoming a 2-3 hour/week skill

Each prediction includes my reasoning, timeline, and what developers should do to prepare.

👉 Read the full article with all 10 predictions and analysis →

Methodology

Based on:

Stack Overflow 2025 AI Developer Survey (71,000+ devs)
18 months testing 20+ AI coding tools
100+ conversations with developers in production
My own production use at ICANotes (healthcare software)

Not based on: YouTube demos, marketing materials, or Twitter hype.

About Me

I'm Boki, a senior full-stack developer in Serbia working on healthcare systems. I run intelligenttools.co where I share honest, technical AI tool reviews from a developer's perspective.

What's your boldest prediction for AI coding in 2026? Drop it below 👇

--- title: 10 Bold Predictions for AI Coding Tools in 2026 published: true description: 10 predictions from 18 months of production testing (some will make you uncomfortable) tags: ai, webdev, predictions, coding cover_image:

Bojan Tomic — Fri, 26 Dec 2025 11:34:17 +0000