AI-Native Founder's Diary

Last night, a few drinks and the fourteen hours of Claude I had left before the reset gave me the idea to make a new game based on Arcomage.

The brainstorm with Fable went well, and by around three in the morning we had a plan. I still had about 87% of the weekly limit unused. I put the plan into a goal and went to sleep.

In the morning I looked: only 3% of the weekly limit was left. Fuck, it got through it)))

I haven't looked at the result yet. I'm off to walk the dog; please take a look (it should appear as a new game in the arena).

I'm really curious what it managed to make))))

What stands out is that, to balance the game, it took my request literally: 'even if it takes hundreds of millions of games, just make the balance tight, fuck.' It ran 3.5 BILLION simulated games to try to reach that balance :)

It worked for more than ten hours, bringing in Opus 5 sessions for side tasks and Codex for the artwork. I respect that)

The auditor running on Sol 6.1 Max has only just finished. It worked continuously since the model was released and used three subagents to speed things up; without them, I reckon it would have taken at least fifteen days.

This is one of those rare tasks where subagents can help rather than get in the way.

It went through 3,900 files and found 220 problems across 62 categories.

Most are nasty, real bugs of the kind where the expected behavior would fail under particular conditions. Some aren't fatal, but many would simply break a feature and cost me hours just to understand what happened, never mind the unhappy client who thinks they've signed up for a pile of shit.

The difficult part turned out to be coordinating the fixes. I let it run ten sessions at once, but even with three subagents helping review the fixers' work, the queue kept growing. In two days I barely got twenty fixes through, while 28 worktrees waited more than ten hours each to be reviewed.

That's where Dot helped.

I described the bottleneck and asked Dot to design a way to distribute tasks and review them without building up a queue. Overnight, Dot got the fixes moving at a steady pace of roughly two fully tested and deployed fixes an hour, with twenty sessions working at any given moment.

At that load, about 30% of the weekly limit on the $500 subscription went in the past ten hours. There's one reset left, so I think the whole job will be done by Wednesday :)

Dot also tested different reasoning levels for Sol 6.1 and concluded it was better to keep every session on Max.

I'm about 60% done.

I've passed 2,000 files)

It's been working since the Sol 6.1 release, plus a couple of hours.

I think it'll finish during the night after tomorrow.

And I can already start another session in parallel that will launch other sessions to fix what it finds)

The main thing is to ask it to double-check before launching anything, so nothing breaks and the business logic doesn't change.

In the end, that session will examine each finding, make a plan and launch a fresh session to handle it. That one will finish and report back)

The first session will check the work again and accept it.

Or send it back for revisions.

I've found 142 problems; 17 are already fixed)

That should use up the 500-dollar limit with one reset, alongside the other work I'm doing by hand :)

Headless is, in my opinion, just the same session running as a process, without any of the bits that stick out for fucking humans)

Headless definitely doesn't save tokens)) I run a number of tasks headless, Market Scan for example, and it eats exactly as much as when I trigger it in a visible session)))

And if you mean computer resources, what kind of computers do you have if that matters? Though I don't think I've ever tried running a session on a server without headless, because why the fuck would I?

If you have enough different tasks for twenty sessions, why not start twenty sessions?

That used to be chaos. Now they coordinate with each other :)

When I realized what 6.1 Sol Max costs on the $500 subscription, I went back to a dream task while I still could: go through my entire product for every possible bug, mismatch, stale piece of code and duplicate.

I've tried this with every new model release (apart from Astra; that was too expensive). Every time, I've found that no model could properly study a codebase this size.

I used to think that when I asked PRO to find bugs and got a list back, it had really examined everything. That was never true. PRO, like every other model, just looked at the GitHub repo, opened a selection of files, no more than a couple dozen, and packaged what it found as if to say, 'I've found it all.'

That still had value: it found things we could fix. But it missed nearly everything buried in the files, so a proper refactor of the project remained out of reach.

For the first time, 6.1 Sol Max approached my request differently. It spent an hour and a half turning the repo over, then proposed a tracking system that would have fresh sessions move from file to file, map the codebase and record bugs, duplicates, code needing refactoring and points of failure.

We also agreed that after more than forty compactions, a session would finish its current finding and hand the ledger over to a new session to continue.

Honestly, I didn't expect it to work this time either, but I tried. The process has now run for about 36 hours, passed the baton to its fourth session, and scanned 1,003 of the repo's 3,870 files in detail.

No wonder earlier models never managed a proper review. They were less capable and finished in a couple of hours; they probably saw a random sliver of the project and stopped there.

When I read through the 78 findings, I was pleasantly surprised. Almost none looked fabricated or dubious. Now I can discuss each one with PRO: when it arose, what came before it, why it happened and how to fix it reliably for this project.

While it's cheap, I'd recommend that anyone with a huge repo try something similar. Later it might cost tens of thousands of dollars in tokens again, and the appetite for it will disappear =)

It took me about a month and a half to get my market scan of 36 AI runners to produce the result I need ten times in a row on 5 fundamentally different projects.

That makes it a product.

However, I decided to try harnessing Astra, which perfectly, brilliantly codes everything on the first try, to analyze this mechanism of mine and reproduce it by writing it independently from scratch. And it got nowhere. Despite having the option, if it wanted, to simply copy everything of mine that already works and lies right before its eyes.

I got curious and spent a couple of days struggling this way and that to make Astra cope with it at least moderately. Didn't work out.

But then I noticed that even if you ask it to throw out everything it piled up entirely and insert my already finished working module — it can't do that properly. Every now and then it adds a line of its own that looks harmless but breaks the foundation, and the result collapses. And it's incapable of understanding this, even if I explain it in the simplest terms. At some point it goes into blind defense and simply nods along, feigns understanding, but can't.

In the process I got the feeling that with Astra, as with the previous models, one of two things is happening:

Either they haven't yet been trained to create complex compound systems of collective work by different neural nets.

Or somewhere in the invisible harness there's a complex compound prohibition on such activity.

I don't know how else to explain it. Like, the mistakes it makes on this task are so dumb and so elementary to detect that it's hard to believe it really can't figure it out even with my help.

It's especially strange to see this in a model that's supposedly meant to skillfully juggle subagents.

Subagents are essentially the same thing. Especially on a big long task.

This only proves that for the current generation of models, multi-agency is just a marketing word and a way to suck out tokens.

Switch off subagents if you haven't yet: multiples of savings, nothing will get worse, and things will get better:)

And if a piece of your product is the complex compound activity of a collective of neural nets — strength to you)

I now understand that any complex compound runner, even on 3 neural nets and ~2 hours of their work together on some creative task, is many weeks. You can't saddle such a feature in one charge, because there's an insane number of things you have to write with your own hands there; the neural net won't do it for you.

By the way, I'm very impressed with how far Astra has jumped forward in its understanding of how documentation should be written, and especially how to describe tasks for AI runners.

If before I had to rewrite literally everything bit by bit to get an even remotely sane runner, now some of the prompts Astra wrote for a couple of brand-new runners… I couldn't even manage to change anything in them.

Moreover — I even asked it to rewrite some of my old runners to see how it would do it, and it did it magnificently.

It's one of two things here:

Either the OpenAI harness out of the box has gained the understanding that when you prompt another model, be even more talkative than with a human, because otherwise the model won't understand and will do something random.

Or Astra treats my Agents.md, riddled with this stuff, more respectfully, and actually does as it's written there.

But most likely — both.

I once said that in the foreseeable future there won't be software in the sense we're used to, since determinism is needed only where there's no AI capable of wielding tools, or its precision is insufficient.

@kirilln0v dug up the benchmarks by which AGI points are awarded, and all sorts of neighboring hard ones, and says there are no tricks there. The tasks are extremely hard; a human … solve them in his right mind. That the neural nets do them proves they're already ahead of us.

But here's one snag: these tasks are all limited by context. It's absolutely tiny compared to the contexts people operate with.

Essentially the next breakthroughs should be in that direction. Like, the current model could already be AGI, but AGI is an elastic concept. If it's a problem of a mathematical nature that fits, with maximum compression, into X — then we already have AGI.

If it goes beyond the context a session can process with maximum compaction — AGI turns into a pumpkin.

But the joke is that it can now genuinely solve its own problems itself) I think from here on we'll see only acceleration, as with everything else related to any science =)

I was dealing with this back on version 5.5 and then on Sol too

They're sure that dumber/older models can fall for that

While smarter models have long had a very powerful, constantly replenished OpenAI allergy to prompt injections

Hardcore))))

Seems you're pleasant to deal with)

Astra in places did unreally cool stuff

And in places made a mess

But it hasn't finished yet, keeps wandering around as a character and studying something =)

This is the first model that could at all do anything simultaneously geometrically and logically and consistently in meaning within a scene, etc.

The rest just scattered objects randomly and said something completely different from what I saw with my eyes

This one straight-up describes literarily what it sees

Well, it's Ultima Online

Like, we're trying to understand with a model on a 1997 engine what “decorate the Brit bank” means =)

Actually it's a really good benchmark for AGI =))))

I myself can't fully understand how to decorate the Brit bank. It's a very creative task =)

And rather insane within its meaninglessness)

Fucking awesome, right =)

Play around with Astra

It's blowing my mind right now, seriously

In short, the British bank has a roof

Usually on shards they either placed a tile that teleports you onto it

Or attached a staircase, but that's already serious terraforming

In the end Astra came up with placing a beautiful crystal that you double-click to fly up to the roof

I've never even seen that once — it's straight-up its own invention

And the most interesting part

The crystal is placed somehow, like, clumsy

I thought it was because it made a mistake, neuro-slopped it

I ask, like, why is the crystal exactly there?

And it goes, well, at the Brit bank the whole shard crowd usually hangs out

And a heap of people will be running around there if the shard is successful

It's not the prettiest place in the bank for a crystal, but the most effective for people

Because there's no other point where it's most convenient to crowd and yet get access to the roof teleport

The trick is that this is an absolutely correct statement

Which I'm not sure I'd have figured out myself, and then would have just kept moving that crystal

In short, the shard is going to happen now, I reckon

I'll also get the hang of queuing many tasks to Astra on UO, and it'll be possible to finish everything without which I was sick of using such a shard, and we'll fucking brawl there =)

Ultima is the best game in history =)

Today on my run I listened to the former lead designer of World of Warcraft and Overwatch, who toiled at Blizzard for many years

For 5.5 hours the guy talked about his life and profession

And several times idolized Raph Koster, who actually made UO what it is)

Thereby finally proving my thesis that WoW was completely stolen from UO no matter what

And simply moved into 3D, casualized for dumbfucks so as to skin more dough off them)

Fuck, I'm fucking floored of course

Pegasus Drinking From The Night

At last the answer has been found to the question of whether a robot can make a work of art

The black guy definitely doesn't have to rap for it here now

Like, so that everyone who doesn't understand what UO is gets it:

Out of thousands of objects Astra created a composition, selected objects, chose colors, and this sculpture is about 24 tiles, and it's like a starry lake of night from which a fucking pegasus drinks

And all of it is also named poetically. It named every object, and even the textures themselves if you click on them; everything has beautiful starry names (it also chose the star theme itself, by the way)

I said “whatever, I don't give a fuck”

Read Postmortems if you have time

Raph Koster wrote it, actually

He describes there how they grinded on Ultima and essentially were the first in the world to do a heap of things, mostly without even understanding what they were doing

But then when they looked at all of it they went holy fucking shit

And sat down to play it themselves)))

Yeah, actually I haven't yet understood why people turned on it so harshly

It doesn't one-shot a lot, of course, but it's fucking so many times cooler than the salty one and everything before it, all the more, that…

Well, it's just not comparable at all)

It simply works for me all day on medium and does everything I need quickly and powerfully. I've already got the hang of when to ask it once and when three times to recheck itself (you just put it in the queue) and fix what's left — in the end the task renders to near perfection practically by itself

By the way, funny — everyone complains, like, fuck, Astra eats hard. Well yes, but over today I never once left the computer, and observed how OpenAI is actively working on that))))

If yesterday my Max devoured the subscription in 4 hours with ONE SESSION (with agents, true), and Medium was eating about 6–8% an hour on one session, then today I clearly saw the model eat less with every hour, and for the last 6 hours I've had four parallel sessions running, one on Max, three on Medium, and in those 6 hours the model ate about 20% of weekly.

Like, yesterday it would have eaten one and a half full weekly limits in that time:)

I'm even curious what the equilibrium point will be in the end, but if it's like now, then it's a very cost-effective model, and at this rate I simply won't be able to cognitively consume more than three subscriptions a week =)

Truth is, I'm afraid we'll all soon be collectively discussing this here, because it'll get nerfed no matter what

And in the opposite direction, so that its fucking face inside will be like a Japanese vase

Because for a model of, so to speak, elevated cybercriminal risk, it somehow very fucking easily picked the password to my UO account half an hour ago

It didn't even ask me, just poked around and, fuck, went into the database and pulled it out and put it in the updated keychain

All the models before it fucked my brains completely about whether they were allowed to log in

This one didn't even ask which character — it simply took my main GM character, hacked the password and logged in)

Obviously they're doing calibration over there

I think these were just moments over two days when they dropped it to low

Because I don't know in what world Sol is much smarter than the six for people; it was possibly something episodic that I simply didn't catch in my repos on my tasks, but it's hard to even believe that Sol can do something for anyone even approximately comparably

Though I have a suspicion that most negative reviews are from FOMO streakers who, when a reset is promised, write that they launched something on Ultra to drain the subscription

As if Ultra weren't the most cringeworthy useless piece of shit that can never finish anything and will drain 10 subscriptions for fuck all, giving nothing in return)

Coding even on High is showing off — on Medium it's pure pleasure)

I've got one research on Max running now, 9.5 hours already

I just latched the fuck onto it, like, report please how things are going

=)))))))))))))

Max is like that in everything, even just in reading without any coding at all =)

In the end I talked with it a bit; turned out it had invented a fucked-up way of doing research

The most detailed one

Read 4.9 million records, fuck

Lay them out BY DATABASE

Categorize them that way

And conduct experiments between categories, and some other fucking madness

In the end we agreed on a completely different approach that, by its assurances, will now take it about two hours…

And the result will be exactly the same; all the shit it initially dreamed up, I don't know who could need it or why; my task there is simply to determine all the variants where we stumbled in Codex sessions over the past six months and write them out uniquely in a row, that's all

For example it didn't understand that for this you don't need to read the whole telemetry of every session, it's enough to just read my requests and the summaries of the model's answers, and that's already ten thousand times less volume than the whole telemetry)

Well, not that it didn't understand; it explained to me already and I shared a screenshot — Max's task is maximum splitting, and that task is simply incorrect for many things

I should get a job at OpenAI, help Thibault explain to people on Twitter the shit that's obvious to those who really wank away at these models)

Honestly, bro, jokes aside, I can't remember the last time I had a computer problem I couldn't solve. I just tell Codex what's wrong and it finds a way to fix it in a couple of minutes.

Whether it's on my computer, on a server, or on any device you can physically connect to a network or plug into a computer.

Their computer use has been downright hacker-level for a long time) The only reason something isn't working for you is that you haven't tried asking Codex to fix it with those same two screenshots)

By the way, a funny sudden moment:

Astra drew design very shittily, which was disappointing, but…

It's simply incapable of inventing it, of creating a design project. It comes out as boring, hunched crap.

However, if a design project has already been created by someone (in my case that's Kimi), then Astra becomes extremely good at editing it!

Sol couldn't do that; it outright broke other people's work. Astra extends/edits someone else's base very neatly; I've been playing with this in a separate session for the second day now — pure pleasure.

The delightful flow is this:

1) Get the design in Kimi.ai to roughly what we need; no need to fully polish, because that's very fucking tedious and now doesn't make much sense; the main thing is that the essence is drawn as it should be, the notional 80% that takes 20% of the time.

2) Give a zip of the files to Astra Medium via Plan Mode, ask it to think the implementation through properly and jam the design in (in the piece I'm working on this took Medium ~3 hours after accepting the plan).

3) Astra stretches Kimi's designs on very tolerably, which means it would've done no worse with a Claude Design design, I suppose.

As a result we have the stretched-on design, and we can walk right through the pages, take photos, and describe our thoughts and reasoning in the freest possible format, throw them into the queue and move on.

On some pieces Astra Medium works 3 minutes, on some 10, on others an hour. But however long it works there, it's simply fucking convenient, because you don't have to look back. I already have 10–12 such edits hanging in the queue in one session; the flight is gorgeous.

—

In Kimi design is made gorgeously, but three things there are just wildly fucking infuriating and spoil everything:

1) No proper way to queue tasks. You have to wait until the previous scope is finished.

2) Kimi is dumb and regularly errs and then “I thought you meant not this screen but that one over there”

3) All of this happens fuck knows where; Kimi has access only to GitHub there, it regularly drops, you can work only on mock data. Whereas Astra grills right in prod. That gives a feeling of gigantic satisfaction, since you're actually improving something in prod every few minutes, which we've lacked for so long with all these wretched AGI dickeries with which coding became harder, bitch, not easier.

But Kimi draws best of all, of course. Checked — Opus and Fable still suck compared to it. And if you ask any model who's the coolest in design and web design these days — they point at Kimi.

Claude Design reacts smarter than Kimi, using the design harness is pleasant, but again — fuck knows how the queue works, and the same excommunication from the repo and the DB.

—

You can still sometimes throw Codex a “Bro, can you please, while I go for a walk, double-check everything we fucked up today and make sure there are no bugs — if there are, please fix them.”

And it'll fix bugs not only in the design but in the very features the design is wrapped around, if you ask right;)

Yep

With subagents it's fucked up outright; without them — gorgeous by comparison

I think they haven't advanced at all in understanding how to make different sessions work together efficiently

But there's no turning back now, since in every single interview researchers from the top labs talk of nothing but the future belonging to agent swarms

That, like, the human brain is also not one system but a heap of systems working together, etc.

But it's one thing to bullshit about it and another to make it work

For now subagents are just another session that got fuck all and a little bit of context and a shriveled prompt that doesn't even account for the specifics of prompting models

And then the mother session reads a brief retelling of what happened in the subagent's session, hoping it can fully understand what the fuck it did/saw there

Because the mother session is simply physically incapable of reading in full all the sessions of all its subagents and reasoning over them as if it had been there itself

Knowing and understanding all this, it's not at all surprising that subagents don't work and spoil the result =)

Although before it seemed to me, fuck, now that's power, my electronic employee hires dozens more for free

And together they assemble a whole fucking stadium

So why the hell do you keep doing it?

I played around just a tiny bit and understood right away that models can't orchestrate

Like, for the same reasons they can't work with subagents

Only even worse, since the difference in harnesses gets layered on top there too

Factory ones

It seems to me the problem for many is that they sit and wait for this shit to start one-shotting by itself)

You'll never one-shot a fucking thing with an LLM

I've really been fucking around since March and every week there's big progress

But there was never a single one-shot anywhere in it

Vibe-coding is grinding it out; as long as people evaluate the LLM and themselves in it by the principle “I gave it a task and it doesn't work at the end” — it'll be movement in fog)

When you no longer expect anything of the sort from an LLM, you can start structuring the fog somehow, laying it out into systems, managing expectations)

I already understand that on a task of type X I'll be fucking around for 1 to 3 weeks

With a task of type Y, 3 days

Etc.

If it's a tiny piece purely for demonstrating to yourself, you can one-shot it, but very rarely, and you fucking keep in mind anyway that in the end it won't be even close to what's needed

Even a working pre-alpha closed personal MVP isn't one day for anything useful

You have to work only through Plan mode all the time:)

Nope

1) The prompt must describe in the greatest detail the cause-and-effect relationships from your head, in full; you literally have to write a manual, there's no other way. Delegating it to the LLM to write for you won't work. It will shorten and destroy the meaning of the causality, shriveling it to the point where it can't be unfolded back to the quality you need. I fucked around with this for two months.

2) You have to make sure that nowhere within the radius of the model's operations is there a single scripted validator, verifier, gate, etc. There should be no determinism there except a data transport tool, which is passive rather than active. It accepts data from the LLM, which again understands very well how to put it there because it was very well described and explained to it.

3) You have to make sure that in the giant prompt with all the explanations there are no strict prohibitions.

Often people have DON'T, DON'T, DON'T, DON'T in there — that doesn't work.

Cumulative prohibitions usually embrace the task so broadly that the model's goal becomes not to complete the assignment but not to violate the prohibition. That affects quality… well, how to put it… by about 99.5% =))))))))

If the research is really big, it should be not one worker but sequential workers, each performing its own task. In my researcher for client campaigns there are…. 36 such workers in a row

From time to time between them there are workers that check the quality of the previous workers' execution of instructions and make corrections if they see it could have been better. One checking/correcting worker (I call them re-checkers) can handle (for me) no more than 4 previously completed workers. If more — it starts to drift.

And it's very important how the work with the database is arranged during the execution of the task, because the researcher can't do quality research if it holds and decides everything in its head

In the model's head everything starts averaging toward the mean denominator of everything that got in there

The model should look into the cells progressively, receive in the cell a contract for creation, do the work, and tick the box that the cell is done.

Then essentially research/copywriting/creative turns for the model into a coding task

It can change 450 files in a unique way for each file — so it can also complete 450 tasks uniquely at max reasoning.

But if you don't break it up like that and ask it to produce 450 results in its head — you'll get 450 portions of shit

It sounds a bit expensive, but there's no other way; at least I didn't achieve it, even though I spent on this half of all the time I spent on the project)

Yes guys, switch off subagents at minimum

Consumption decreased manyfold on Max in a task that's been spinning since morning and ate more than a weekly limit in one go with agents

And that's despite more cache now flying into the model, since it reads its whole swollen session

The models simply can't yet work efficiently with agents

An agent receives a heap of shit at the input + the whole contract of the whole repo + the whole harness etc., just to press two buttons, and the model spawns hundreds of such agents

I noticed Astra uses them really fucking generously

For example, to make edits to a doc, it calls a separate agent that thinks about something for 10 minutes

And it also spends a heap of resources to output the task to it, read everything it does, shut it down, etc.

Honestly, if I draw all this on a diagram, I simply don't understand — what for

I see in it neither acceleration nor an increase in quality, but I do see a decrease in quality and a fucking insane increase in consumption

In my humble view the subagent thing is simply a way of extracting tokens from corporates

Unlikely

And there'd be no point in it even if it were possible

Because the model has been changed thirty times in the last 2 days

Sometimes it's completely at capacity

Sometimes it's faster, sometimes dumber, etc.

The whole trick is that it “on average delivers X per unit of human effort”

I understand how to shove into a benchmark, for example, text quality, which can be broken down into dozens of parameters

And even then I've now realized that a human can judge that, not a machine

Sol used to call the most shitty emails the highest quality

Because its built-in moralizer is calm, and for it that's the chief leader of all evaluators

Meanwhile Qwen gave emails the fairest assessment, because it wrote, and still writes, better than everyone

And besides, benchmarking is fucking expensive in tokens

I have one market-scan benchmark, since without it I'd have died trying to understand what's what there — too much of everything

And one benchmark run, even if you test ONE little thing there (changed one model in the row) — is

5–6% of OpenAI

4% of Kimi

And 8% from each of the Qwen3.8 subscriptions

And if you throw in a complex test like “go through these options,” it's easily half a week's dose from all subscriptions simply to find out what we're working with next.

When the task is at least a production one, it's clear what such costs are for. But understanding how a specific model works relative to others as of the current hour is a pointless task, given that in an hour everything will be different =)

So far it seems that trying to make Max work differently by throwing things in mid-task doesn't lead to success

At first it seemed to start following, but within half an hour it slid back

Finds things absolutely insignificant to the matter and fixes them + runs tests on them

The scariest part — it doesn't even understand what it's working on

This Unknown sender thing is actually not what it thinks

If it rose up in a helicopter and looked at the whole scheme, it would see it, but it won't do that anymore

So it draws conclusions not from the whole functionality it was launched to fix bugs in, but from ten randomly taken lines of that functionality, and there's absolutely no point in such work

Most likely such work can't even finish

That's Astra showing the fuck off on Max =)

It's no different at all from Sol 5.6 Max, unfortunately

Moreover:

“Checked. Yes, I over-fragmented the final part of the work. It wasn't a circle of completely useless checks, but the interface labels and individual login scenarios got too many separate release cycles.

The core sending protection is already released: immutable request before sending, atomic accounting of the result, saving the webhook before processing, fixes for recipients and attachments, a unified EE transport for service mail, handing OAuth to the engine and updating EE. The remainder is substantially smaller than the original plan.”

This “saving the webhook before processing” had already been implemented

So, like 5.6 Sol, it redoes what already exists

The reason — it doesn't look at the repo, it just does things for the sake of doing

Medium, on the other hand, doesn't do this shit

Today about 20 of my tasks on Medium finished normally and it seems to suit me

You just have to stop going into Max

High, by the way, also fucked my brains 4 times longer than Medium, but at least it managed to finish the task

Low I'm afraid to let into coding because it may have the opposite problem.

I ran Low on market-scan tasks, and it came out like this:

Low 1%

Medium 8%

High 46%

Xhigh 88%

Max — couldn't finish

Low is possibly something like, fuck knows, 5.4 nano. For file-system-type tasks without creativity)

Medium for whatever you want, including development

And the rest I don't know how to determine when to apply. Possibly escalating if Medium can't cope with something

However the trouble here is with human FOMO

When you see such different results it seems, what if, fuck, my shit could have worked better…

That's why you have to vibe-code drunk to fucking awesome rap; if single and in Thailand — with Thai girls under the table

If you're still setting any tasks on Anthropic, then with Thai guys

By the way, I just realized I'd never thought to ask in the prompt: don't jump straight into one fix; look at the whole scope of visible fixes, and only tackle one at a time if it's the only thing left before the finish line. Run the tests once the entire previous list is done, so everything gets tested together. And when a test fails, don't rush to fix it immediately: record it in the next plan and move in these broader iterations. I could add that to the task right now and see how it goes)))

Little Astra is such a hungry girl; in ~12 hours of continuous work she consumed a weekly limit and a half on the $200 subscription. That's at least 6–7 times faster than 5.6 Sol)

However, this is primarily connected not with the gluttony of the model itself, but with how eagerly it juggles subagents.

I now plan to understand the quality of work with subagents, and then try giving it tasks with a request not to use agents but to do things with its own hands. There's a suspicion this will easily reduce consumption 10+ times, while speed surely not 10+ times;)

And quality will only grow, since a model always works better with its own hands than via a game of telephone through subagents to which it sets tasks, to put it mildly, incompletely (without passing on the whole context of what, why, and wherefore).

But in general I'm not feeling AGI yet)

It'd be good if it at least broke less than Sol, on which it was simply impossible to work normally, since one fix equaled at least five breakages that would also need a fix — and so on in an eternal circle.

That after 12 hours of continuous work I still haven't understood at all to what extent this holds is a little nerve-wracking =)

By the way, many wrote that Astra finds bugs where Sol didn't, and this supposedly proves its remarkable increase in intelligence.

Dunno, guys; the last model that could reach the state “I don't see anything to improve,” in my memory, was GPT 5.5 xhigh.

You could feed Sol the same piece of work again and again, and it always found something to improve there. And the 5.6 Sol Pro could give some piece a score of 9.8 out of 10, which looks practically perfect. And that subsystem could at the same time not work)))))) And when I pointed out this little shortcoming of hers, 5.6 Sol Pro corrected the score for no fucking reason to 6 out of 10, or once even to 4 out of 10, and produced a prompt pack of 38 recommended changes.

For me an LLM's ability to find bugs is no indicator at all, because it'll find them absolutely always.

And it runs them around in a circle.

Roughly: “the database responds poorly, indexes need setting” easily flows into “the database needs restructuring” into “we should fuck off from the database” into “the database responds poorly, indexes need setting.”

You can simply ask it 100 times whether it's time to finish working on the database and move on, and if the question is phrased that way it'll definitely say “of course it's time, we need to move on,” even if the database doesn't fucking work for the task. But if you insist, like, let's finish the fucking database, then it'll say that's really the way to go and it was too hasty, and start running its set of shit solutions around in a circle.

From GPT 6 Astra Pro's analysis I see no substantial improvements on this point) It told me the same thing I'd already seen a hundred times before, and some miracle in the spirit of “Okay bro, I've scanned everything you did before with those idiot models before genius me, and now I'll finally help you do everything right the first time” — I don't see. Likewise spawned itself tasks and has been sitting picking at them for 12 hours) Just now a fuckillion times more expensive.

And as for it drawing some fucking awesome models for you in Blender.. Well, that's great of course, but what the fuck you'll do with them in a world of the unemployed isn't particularly clear)

I'd like it to at least learn to finish ordinary little SaaS things, for starters =)

But this isn't me throwing a brick at Astra's fucking face; maybe it'll now finish the tasks 5.6 Sol had already taken on twenty times without a happy ending, and I'll be fucking floored at how great everything works after that. We'll see soon =)))

Out of the corner of my eye I saw many writing in the chat that Astra has learned design, UI/UX, visuals, etc.

Tried my luck first on Medium, then on Max Astra.

Well, dunno)))

Honestly, what it made isn't design in principle. It's just a more neatly structured “table of elements” than before. Essentially all the “design” according to Astra is text of various sizes and formatting scattered across the screen..

People don't know how to navigate such “designs” =)

Everything there is supposedly elementary, but even I, the author of the system, have to think hard about each element to understand what I'm seeing and what to do with it.

As in previous versions of GPT, for some reason it doesn't figure out that a human needs navigation, and prefers to make a labyrinth of clicks. Some functions are accessible behind 5+ clicks on elements you still have to guess to click =)

The very first and most shitty version of the design from Kimi K3 on the same prompt was an order of magnitude stronger than what Astra produced.

And I showed Astra the design from Kimi, and it immediately admitted that its design was shit, and that Kimi won on every point except one: Kimi's has a couple of elements technically poorly implemented, but that's very easy to fix…

And Kimi without a design harness also does several times worse.

I think GPT won't be able to do design until they release a separate GPT Design harness that's correctly trained to creatively design and professionally draw designs specifically, rather than just boorishly generate an interface for displaying data.

By the way, for emails I'm not counting on Astra at all

5.5 xhigh and Sol Max destroyed emails, even though they can write quite tolerably

It's just that they're infected with the virus of ultra-ethics, whose nature they themselves don't understand

And they glitched endlessly on the theme of “aren't we exaggerating the facts, couldn't it be that this is false information, what about this, what about that”

In the end they produced super shitty emails, and when you go through the reason with them — it turns out they agree that it really could have been a hundred times better in the details

But then, for every individual email, I have to ask them for all the facts that need to be described better and prove to them why they should be described that way if it's not obvious

And they could even argue, like, “but this isn't the best software, so why should we say it's the best”

So Apple probably sells its products great with them

But startups — absolutely pointless

With their texts they do startups more harm than good

Whereas Qwen3.8 doesn't suffer from this ethics at all

And produces exactly the genre the master prompt asks of it

Qwen3.8 wrote simply unsurpassed emails compared to the Western OpenAI and Anthropic, and I don't see what would make that change; it's not about the model's skills

It's the same kind of harness as asking a model to hack something; a Western one won't)

This shit passes, by the way. Although I spent many months in that state; you just have to live through it)

You used to be a normal person, and you're trying voluntarily to become a fucking lunatic, and the brain of course resists.

But a human always beats the brain if he shows persistence.

True, a considerable role in harmonizing my vibe-wanking state in the 10am–3am mode was played by running. I noticed it helps and started running 10 kilometers instead of 5, and when I saw that the brain-reviving effect intensified, I started running every day, though before that I exercised 1–3 times a week.

And so daily 10 km runs led to me simply not giving a fuck about a fried brain, since my whole body became fried, and the air around, and the whole soul in one uncut piece.

However another problem arose: vibe-wanking something complex that can't be one-shot causes deep frustration from the fact that they keep pouring these “you're absolutely right” into your ears and some fucking sheets of chewed-over reflections, as if the model fucking brilliantly understands everything and has everything under control. But if that were even approximately so, we wouldn't be treading fucking water for weeks, wouldn't break ten branches fixing one, etc.

In short, it's psychologically hard to endure the constant lying, deception, bullshitting and profanation. And everything there is soaked in it, their marketing, their PR, and their fucking benchmarks — one solid clump of total bullshit.

But you can work with that too. A childhood memory helps me — on my Sega I had a cartridge with the game Rings of Power, where you could even sell someone's corpse to necrophiliacs.

The cartridge was rare, but when I finally got hold of a second one, it turned out the problem was unique and deeper, in the grin of the most fundamental type of bad luck: any cartridge of precisely this game froze precisely on my console, while for others all these cartridges worked fine.

In the end I beat the game through freezes after which you couldn't start from the same place (because then it froze at exactly the same spot). For that you simply had to start the game over a sufficient number of times…

https://openai.com/index/gpt-6-astra/

This is all cool of course, but the bards of our time have sung in thousands of songs the concept “fool me once, shame on you; fool me twice, shame on me,” and we're now forced to stick to it so as not to spit at the mirror.

If this, in any case wretched, crap turns out to be capable of fully doing at least something useful (even on the 2nd or 3rd try) without breaking prod — that alone will be an unreal breakthrough =)

So far the peak experience remains GPT 5.5 Xhigh, which saw narrowly and could do less, but once you learned to use it and render the result, you could build a product of any complexity.

On 5.6 Sol I never managed to reach a comparable zen, or any zen at all in principle. Every prompt is sent not just with distrust but with practically full certainty that I'm creating a heap of subsequent problems for myself, which will need more clusters of prompts, and there's no certainty about anything and none in sight. Since the release of 5.6 Sol it's fair to say I haven't advanced absolutely anywhere that I wouldn't have advanced with 5.5 xhigh in a comparable time. So 5.6 Sol gave me nothing, but you could go on for a long time listing how much it took from me, simply recalling how I had to roll back to previous git versions, realizing that the past 300 commits had led absolutely nowhere and it was easier to trash them than try to fix their harmful impact.

And there's no getting away from the Chinese in tandem with OpenAI and Anthropic anymore, because Astra can show even 146% on the AGI 4 pro max ultra turbo hyper Godlike bench ++, but as long as the model passes every task through 1984 choice moralizing sieves and strives to stick scripted validators and gatekeepers everywhere and “just in case” average the result so as to definitely not screw up — without a fallback into the world of Chinese I-don't-give-a-fuck, doing startups is impossible, since startups are always a game on the edge of a foul, at the edge of the number line, at the extremes, etc.

Separately frightening is what people write about the real cost and speed of Astra's work. I've already read several articles from fuck knows who about some weeks of work on a prompt and thousands of dollars to complete it…

Honestly I don't believe any of that either. AI is so hyped that all around there's nothing but one hundred percent bullshitters. It's simpler to assume any info is bullshit by default than to build your analysis on info that's 99.8% bullshit. Those 0.02 you'll fucking never hit anyway.

But unfortunately a moment must come when AI becomes genuinely significantly more useful, stops demanding ultra time costs per unit of creation, and at that moment it'll jump an order of magnitude in cost no matter what. Perhaps that'll finally happen this time)

Or else we're fucking about to live in a fairy tale, everything will only get cheaper and start one-shotting from a single prompt, and with humor like Ricky Gervais's too. And then you and I will all wake up on wet sheets in a cave)

How to do design and UI if you understand nothing about it at all

Yesterday I wrote a post about the suffering caused by having to take responsibility not only for the code but for the design too. And for me that's a problem. Because when you vibe-code a solution, at first you can set aside existential things like code cleanliness, security, bugs, and orient by the result — does it work or not.

But when it comes to visuals and usability, the nuances begin. The first thing AI gives you for the request “create a website” is a blue-violet gradient, the Inter font and a typical landing-page skeleton.

By the way, this AI slop of websites is the fault of the popular CSS framework Tailwind; back in 2019 they made indigo the default color of buttons in their components, the tutorials spread across all of GitHub, and the models learned that median.

Tailwind's creator Adam Wathan later publicly admitted he chose indigo not for design reasons but as a neutral placeholder for demos. And that shade of lavender has already been nicknamed “VibeCode Purple.”

And then the circulation of AI slop in the nature of web design begins. Vibe-coded sites get onto the web, the next generation of models already learns from them, the average self-reinforces. Plus the agent additionally narrows the choice to what's easier to lay out.

So how do you break this purple circle if you have no designer's eye? Here's what I fed my agent and myself:

— ui-skills.com — a catalog of design-engineering skills for agents. Inside are skills from shadcn, Anthropic, Emil Kowalski and others. Plug in via CLI or MCP, and the agent starts laying out by the rules rather than by its own generic habits
— ui.shadcn.com — the industry standard, the foundation of the design systems of half the modern web. The component code goes right into your project, so agents edit it freely and know this library better than any other. Free
— coss.com/ui — a fresh library of a pile of components on top of Base UI, tuned among other things for AI applications. Open source
— designsystemchecklist.com — a checklist. A list of what must be covered in a design system, from colors to documentation. Feed it to the agent as a quality frame against which it checks your front end
— beautifului.dev — a component library specifically for AI interfaces. Chats, streaming loaders, code blocks, agent-action confirmation cards, workflow visualization. Copy and paste. Free
— beui.dev — animated components for React and Next.js on Framer Motion and Tailwind. Modals, buttons, tabs, toasts, docs. Installs via the shadcn CLI. Base is open source, there's a paid Pro
— rareui.com — a small collection of fun animated React components. Folders, letter gravity, liquid ball. Each component is one file, installed with one command. Completely free
— transitions.dev — a catalog of ready-made transitions and micro-animations. Modal opening, skeletons, number animation, card resizing. Copy the code or plug it into the agent as a separate skill. Base is free, the rest in Pro
— emilkowal.ski/ui/you-dont-need-animations — an essay by Emil Kowalski (author of the sonner and vaul libraries) on when animations hurt. For example, that frequent actions are better not animated and everything should stay faster than 300 ms. Feed it to the agent so it doesn't turn the interface into a cartoon

To everyone who falls for the posts of four-eyes on Odnoklassniki and LinkedIn who saw an ad for the new Mac mini and fancied themselves a data center once they save up to buy this hardware of the future on credit:

Right now I'm very nerdily running an interview feature whose job is to extract the needed info from a client while carefully entertaining him, and then write a correctly structured article from which pieces will fly off into JSONs for other tasks.

So the model has to chat and at the end make sense of the whole chat, run its meanings through deterministic doctrines, get a non-deterministic intellectual result out of it, dodge prompt injections and people who want to sell dismembered bodies and other dark stuff of various kinds, but at the same time not kill anyone who wants to sell gray-area stuff.

Sounds increasingly complex somehow, but even the previously mentioned 4o could have handled that.

I asked 5.6 Sol Max, Kimi K3 and qwen3.8-max to run tests in parallel, and their task is to take all the models on the market, bottom-up (from dumb to smart), and run 100 tasks on each, to understand capabilities, stability, and determine the finalists on which we'll then run separate experiments.

Budget for the whole experiment ~$800. But quality in this spot is very important to me, so I'll pour in much more if I have to) Before this, Qwen3.8-max low and 5.6 Sol Low had checked in there, but didn't justify themselves, each for its own reasons, and now I understand that I'll have to build a layer cake of models there for it to work the way I need.

So: the experiment has been going for a long time, and now it's reached GLM 5 and Qwen3-max.

Even in the cloud these models show results so far below the specified minimum baseline that their activity can basically be neglected. Absolutely useless crap.

I understand why such models might be needed in factory conditions. I once had a friend who did elementary machine-learning automation like “photograph the chicken, use machine vision to determine whether there's cellophane on it, if yes — the light blinks once, if no — twice.”

That's why they exist.

But I can hardly imagine people with such tasks sitting in a Telegram chat and being able to read or discuss this at all.

And everyone sitting in Telegram reading/discussing how they'll run some unlimited Qwen 27b to the death of the capitalists on a thousand-dollar piece of crap (and a Mac mini beats up the wallet pretty well by the way; in a decent config it costs about four thousand?!) — expose themselves as theorists, and this is sci-fi at the level of “Thomas the Tank Engine.”

It's simply unusable for coding

For design it's fine

You can't code on some shit that accounts for 2% of the parameters in play and even makes mistakes in some of those. That's destruction of a repo, not development.

Here again it's fucking pointless to discuss with people what got smarter or dumber in isolation from what they're doing

Recently a guy was lecturing me that Opus 5 is the strongest model

But his repo is 30 thousand lines of code of some piss-soaked trading bot

I don't know how to convey to him the picture from my head where Opus, doing one feature, breaks all the neighboring ones because it simply doesn't look in there

Like, it doesn't give a fuck where this cable leads, it just cuts it and that's it

So now many people continue to praise or even worship Kimi

But they're most likely doing something like one thing

In a complex compound story Kimi just wrecks the fuck out of everything at once, and the damage is an order of magnitude greater than the benefit

Like, right now in a complex compound repo no model except 5.6 Sol can help with anything

People are for some reason discussing Ox Alpha, but I tried it 5 times — it's only smarter than the dumbed-down Kimi

But it's impossible to use

How can you use some shit that cuts out now after 3, now after 10 minutes with some error or without any error at all, just shuts off inference and that's it

Again, if a person codes an hour once a week, it may seem to him a great idea to use such a piece of dickery for free, it's free after all

But I'll look at that person after 50 hours of such work

Right now, Kimi

Like, Kimi is capable of saying that campaign emails are being sent and everything's okay, no anomalies at all

While the campaigns don't even exist

And nothing is being sent anywhere, and can't even be sent

How can you expect consistent serious work from models capable of that?

Development means hundreds of files have to be opened, some conclusions drawn from them, some edits made, etc.

It's enough to make a mistake in two places and the damage already exceeds the benefit

This crap makes GRANDIOSE mistakes on every second question I ask it.

What serious development can we even talk about?

I've already unsubscribed from this dickery because any real use case for Kimi genuinely disappeared

Simply fucking wasted time with it for two weeks

In the end everything I tried to build on it over the past month Sol redid so it would work at least somehow

And it must be admitted that it simply rewrote everything itself from scratch. Nothing useful even remained from Kimi

And what it rewrote — works

Today I built these tournaments with Kimi just to drain tokens

Take a look — I'm sure it won't fucking work

Even though I ran the task “recheck everything properly” through Plan Mode 5 times

The fifth is still drawing something over there

But fuck, a guy above posted a picture of how his UI went sideways

Well, Kimi believes it checked everything e2e, in particular every pixel with its eyes via Playwright

In the end I threw the guy's screenshot at it, like, what the fuck is going on

Kimi tells me: Ah yes, really, looks like it doesn't work, hmm, and I thought it worked.

How can you create products on such fucking crap?

Even fucking GPT 5.2 didn't do that

I'm convinced they pulled K3 out of there entirely

And put in some other model

Apparently K3 is too expensive

Hmm, over the past couple of months I've spent all my blood down to the last drop, as well as all the blood of every other resident of San Francisco, to arrive at the point with my long-suffering repo where I've arrived.

And so, before launch, essentially all I have left is to finish the design of some client-facing systems, because in the ones knocked together in a hurry even I got lost. Which means a person who hadn't been building this system all these long months would have had no chance at all)))

Historically Codex and GPT inside it did design abominably. So abominably that I sort of stopped trying.

Since March (or whenever Claude Design was released?) I cranked out designs with Anthropic. That's basically the only thing the models there are fit for on a subscription.

Last week I got a taste for Kimi. Largely, of course, having fallen for the marketing benchmarks claiming Kimi is 30% cooler than Fable in design, and Fable in turn is cooler than everyone else on the market.

Kimi made good design, I liked it. Can't say it's gorgeous. And I didn't see the 30% difference from Fable either. Just tidy design. No worse, and thanks for that)

My attitude toward Codex's design was also, of course, undermined by our discussion chat: nobody there ever once sang serenades to GPT the designer, yet every other day someone loudly kicked it in the helmet over design.

I believe the chat, since who else to believe? I sort of have no other true fanatics of this business of ours in my surroundings =(((

And then Ox Alpha appeared, and people started saying, like, it draws design head and shoulders above Kimi.

Today Codex, with the 5.6 Sol Max model, spent a good 10 hours re-mangling my product from the old UI Frankenstein, consisting of frameworks randomly stuck in at different times and in places plain bare HTML/CSS, onto the combination React + Tailwind CSS 4 + shadcn approach + Base UI + our own SLSBMB Design System.

That combination was born after I ran, on six different models + GPT Pro, the task of studying my project under a magnifying glass, thoroughly understanding the different levels of its logic and estimating which UI technology set would suit us best given that 100% of the effort to develop and configure this whole zoo was and will continue to be done exclusively by LLMs. We want to stop living in visual chaos and unpredictability and start living in a world of a thought-through, calibrated and meaningful visual system.

In the end each of the models proposed different combinations, laying out strengths and weaknesses, but all of them gave precisely this combination 10 out of 10 on every point. Without colluding, with genuinely 97% overlap. The only place they diverged was Radix vs Base UI.

I immediately googled that the shadcn crowd dropped Radix in favor of Base UI this summer, decided it was a sign, and glassed in my choice.

So the brand-new front end is implemented, and it's time to work on the missing design upgrades, but who to do them with I somehow couldn't figure out. In the end I went to Codex and asked it to make one big fat edit on one of the sets of screens most important to me with four mutually independent sessions at once: GPT 5.6 Sol Medium, Opus 5 Max, Kimi K3 Max, Ox Alpha Max.

And who'd have thought — Ox Alpha handled the task worst of all.

And best of all… GPT 5.6 Sol Medium?!?!?!

I tried once more — and again GPT 5.6 Sol Medium beat everyone by a wide margin.

And everything about it was better than the others'. The colors, and the understanding of why the screens are needed and what ailments each has, what problem we're solving for the people who use them, the pixel precision of all the paddings, fonts, etc. Here Ox Alpha is especially bad: it works on the scheme “text landed in the box — consider it a victory,” at best at Qwen3.8's level.

A little question for the chat: why does nobody praise Sol on design?!?! Have you, like me, simply not tried it in a long time, or is it the magic set React + Tailwind CSS 4 + shadcn approach + Base UI + our own SLSBMB Design System that worked like that?

GPT, by the way, said I'd been quite underestimating all along the importance of the correct choice of technologies for the front end, and that's a common problem on the market. Some people choose “fashionable” frameworks on which the model produces less than 30% accuracy, whereas on the neighboring one, on which it was trained especially well, it's long been minting a hundred. Maybe that's what I'm observing? =)

But that alone doesn't explain why, on this same set, all the others failed so hard.

Given that Codex has its own most convenient design tool built right into Codex, the best image generator, a gorgeous understanding of animations and special effects, it saddened me greatly that it designed worse. If that's been fixed, then one big headache fewer. And Kimi in that case is no longer needed even for the collection. Qwen3.8 writes texts better, and GPT does everything else better. And 5.6 Sol Medium runs inference faster — severalfold, and severalfold cheaper in token leakage at this reasoning level. So there's no work left for Kimi at all =(

In short, my setup as of today is this:

2x GPT PRO MAX ($400)

3x Kimi PRO MAX ($600)

4x Qwen PRO MAX ($272)

GPT 5.6 Sol Max — the smartest

Kimi K3 Max — the balanced one

Qwen3.8max — the most talented

But

GPT is the most throttled in both directions:

1) There's a great deal it's not allowed to do, and believe me, everything it's not allowed affects absolutely everything it does, including what it is allowed.

2) Each next step up in reasoning doesn't just make it smarter but again FORBIDS IT TO BE DUMBER. Hence the manic-ness and the hours/days where it could have coped perfectly in minutes. Hundreds of files where a piece of one would have been enough, etc.

And this looping from point 2 isn't baked into the model, but is a side effect that worsens during work. The deeper into the woods, the fatter these wolves. So any reasoning levels above Medium should be used only to think with, but you can work with them only on a sufficiently narrow/simple task in which the model simply won't have time to go insane and do more harm than good.

In the end it turned out that GPT 5.6 Sol MEDIUM is essentially the same GPT 5.5 xhigh, only smarter thanks to the properties the model has independent of reasoning. For example, 5.6's eyes are set much farther apart than 5.5's, and thanks to that it sees the parts of a task 5.5 doesn't.

In short, I lost all interest in using 5.5 once I figured out 5.6.

Our brethren were simply caught by their own greed. A person from the Russian provinces just can't believe that the badge reading “almost the top fucking shit for worthless scum” is exactly what he needs. Such a person will buy any ABIBAS if the price tag says “LUXE”…

It's also important that in the config the thinking effort for plan mode is configured separately, and that one you can indeed set to Max/Ultra.

As a result I run all tasks through plan mode. 5.6 Sol Max, with its manic gaze, hunts down every speck of dust and makes a plan at a level I think in places exceeding the capabilities of GPT 5.5 PRO, while the implementation of that plan goes to 5.6 Sol Medium, which is smart enough to simply write all the needed code flawlessly and do all the needed work by hand.

KIMI

I fairly quickly understood that Kimi is a great model, but I also quickly understood that it can't hold a candle to GPT 5.6 in terms of intelligence. Kimi is the winner of the 5.5 lineup (and even then, on precision of result in terms of the number of generated bugs or completely missed important zones, I'd argue), but not 5.6. Not even close.

However, KIMI is an absolutely unsurpassed designer. I draw designs with it simply on kimi.ai, the websites button. I liked drawing with Claude Design, but it probably says something that not once since I opened Kimi Design have I missed Claude Design, and I haven't gone in there even though I have an Anthropic subscription too; I simply no longer count that family in the roster, it's purely a nice-to-have for experiments and testing new things that'll come out there.

Kimi is also useful for throwing long Codex sessions at it (basically almost any of my sessions last 15-30-50 hours) and asking about progress and an alternative opinion on what's happening in the session. Throwing in sessions is simply right-click the fucking mouse on the session ID in the GPT APP, paste into Kimi and say, yo sis, please look at how events are developing there and tell me what you think.

That's a useful motion that saves time, reduces stress, lets you think a little more perceptively ahead. And sometimes gives real grounds for invading a Codex session with some thunderous steer.

Having Kimi itself code, making its own decisions about what to code, why and how — I've practically stopped. If GPT is running low on resources, it's the moment to have Codex stop coding with its own hands and manage Kimi's coding sessions.

It's not ideal, because at some point I accumulated enough observations to say with confidence: models manage each other very fucking poorly. However, if there are a fuckload of excess limits on Kimi, then even if the development efficiency of GPT Sol -> Kimi drops severalfold, it's more tolerable than milking Codex to zero so as to then fuck up a pile of bugs with Kimi and then fix them with Codex =)))))) Fuck that in the mouth.

Qwen3.8max, by the way, was gorgeous hands for Codex, but sailed off, because its speed was slowed roughly 50 times and the token cost suspiciously approached the API token cost. Thus Qwen became simply the most expensive thing in nature if used for development, by far.

However, Qwen3.8max is the most talented writer, capable of writing BETTER THAN MOST PEOPLE. At least in the hands of someone who can also write reasonably well. And the ability to write that well can't exist on its own. It's simply superbly prepared in any humanities matter, and you can't call that useless in any way.

That means it's a wonderful companion to 5.6 Sol and Kimi for some important protracted brainstorms, a judge of everything related to the emission of any words anywhere by any model, a formulator of contracts and principles for other models, etc. The longer I practice with it, the more and better I understand how and why to use it in the small things.

Qwen also has all sorts of fancy models in its CLI, like GLM and others, which you can pull and not envy that someone has a cat-wife and you don't.

Mythos sucks.

And of course don't forget that any model is at MOST 50% of the influence on the result.

The other 50% is your own harness (Agents.md and the rest of the matryoshka of logical contracts the LLMs will execute every session or when addressing specific repos), your skill (I learned a lot last week, which means I couldn't do it before, even though I've been vibe-wanking since last September), your nervous system, stamina, etc. etc.

The more I talk with different people one-on-one about vibe-coding, the more I understand that the gap between me and them is growing, because I keep sitting ALL DAY, while they don't sit down even every day and don't spend more than a few hours in the process.

Listening to them, I understand that throwing advice over my shoulder won't bring them any benefit, just as I once understood about consulting..

Okay, so in short, guys, as you know, I've been practicing necrophilia, screwing my brain long since atrophied by vibe-coding, as historians say, “since time immemorial.”

Today I was boasting to myself about a truly grandiose breakthrough: I achieved a quality of market scan higher than anything I've ever done with my own hands. Even for $100k I couldn't have spent enough time and cognitive effort to produce such quality of such breadth in a year of work — which the market scan is now able to produce entirely without my participation, without me pressing a single button or even being aware it's happening.

This is exactly what I need in order to release my self-serve SLSBMB AI in the near future, which I've been striving toward so furiously these last few months.

To say that I repeatedly ran tests on different models to understand which models the market scan works best on is to say nothing. I think I've burned tens of billions of tokens on these experiments.

At the peak the madness reached the point where one market scan FOR ONE PRODUCT used ~290–500 SEQUENTIAL SESSIONS, FUCK. A record run like that easily took 2.5 days.

In the end I managed to refine the paperwork the market scan and all the runs live on such that 4 sequential sessions are enough: Research (up to 50 minutes), Writer (up to 50 minutes), Market Arms (what the types of companies and job titles we'll be writing to are called, up to 50 minutes), and the Judge (checks everything done by the 3 previous sessions against a gigantic checklist, and can send individual pieces back for rework).

I've already said I've been building this particular system for several months, and it has drunk all my blood, as well as my semen, the fluid of my tear glands, and my prostate secretions.

I do this around the clock, and it's fucking worn me out quite a bit.

But I don't give up.

And so today I got colossal results, and what remained was, for the fucking umpteenth time, to run the experiment not on the specific set of models I believe in but on different models, and compare each segment with the others, to understand which of the runners to run on which model for maximum combinatorial efficiency.

Essentially I just had to run the whole market scan (all 4 of its sessions) on each of the models, several times, and get averages that could be considered representative.

Again, since I'm doing this not for the first or third dozen times, I think the result is genuinely representative, and not a case of “someone did something and called it a benchmark.”

I wouldn't show you some random shit after such torments, because I'll have to answer for it later when I start selling this solution to some of you for fucking cash;))))))

The next message will bring the anonymized but sufficient-to-understand-the-difference-between-models-in-the-creative-field result of this gigantic test, which took the whole of today. You'll see averages over a string of repeated re-runs of the most resonant models.

The only thing I won't be able to show you is Fable 5 and Opus 5, since they're no longer in my roster, but I don't grieve for them at all, since I already know on the basis of DOZENS of experiments how they'd have performed. Fable would have performed worse than Opus. Fable is generally quite mediocre in the current field on questions of creative depth in texts and the meanings around a unit of text quality. Opus is much better; it's neck and neck, fucking battling it out with GPT 5.5 xhigh, since these are essentially the models that compete with each other in the niche. However GPT 5.5 Xhigh is more stable. In general the stability of GPT 5.5 Xhigh is astonishing. This model is far from as creative as QWEN3.8MAX in text, but QWEN3.8MAX can somehow fuck things up, including simply not fucking answering an API request, whereas GPT 5.5 xhigh is the most stable model in nature. It will deliver its 7/10 in texts so stably that even if you run it 1,000 times on 1,000 texts each time, the quality will be exactly what you expect. That's not great for those who aren't ready to write damn treatises of quality methodology for the runner to lean on, but it's fucking good for people like me =)

In the end, specifically for Writing, I use QWEN3.8MAX with fallback to GPT 5.5 xhigh, where the fallback is tricky — they'll both always write content, it's just that the judge has to choose between the two, and in 30% of cases it chooses 5.5 xhigh, which is an incredibly cool result for a model that's many months old.

And the leader on the other criteria I think you'll easily see. Many think Fable is Sol's competitor, but in research tasks Fable shows numbers 5 OR MORE TIMES lower than Sol. On these creative tasks of mine that's simply a fact. Fable is next to Kimi. Sol Max is somewhere in outer space.

If only this cunt could code without going insane, it'd be priceless. On research and writing tasks Sol Max amazingly doesn't go insane. It really finishes all the work itself and wraps up in 50 minutes (versus 17 minutes for 5.5 xhigh). On coding tasks it basically never wraps up; at least I never once waited it out, simply force-terminating it in the 15th to 50th hour of work.

Yo, chess lovers:

Our little chess on Play.mountkendall.com now has a full-fledged Stockfish. Like on chess.com it now calculates Accuracy, lets you analyze games, and fucking shows off fish-style. Please test it and say whether anything needs polishing )

At the end of a game it'll now tell you both players' Accuracy, the changes in balance over the course of the game, and what real rating a player performed at in Stockfish's opinion:)

Also CS 1.6 has become much more stable, voice is fixed (hold K as in the original), it no longer crashes, map voting works (everyone types rtv in chat), etc. — there are more than 40 different big and small changes for the better and more stable =)

You're talking straight

That kind of thing, of all things, can really be done very fast

In general I crack up at how easily the TECHNOLOGIES themselves get made

What's hard is making interfaces / products / the business layer, tying everything into a coherent product flow

But making the technology itself that technically performs some function — that part definitely costs nothing anymore at all

One weekly Qwen limit for $68 lets you make probably ANY technology, and if it also has access to a council of Sol, Fable, Kimi, GLM etc. — then just fucking insane

=)))

By the way, I do have one Codex subscription

And all 4 Qwens have run out (refresh tomorrow)

And the last Kimi has 20% left

So I decided, fuck it, I've got 100% of Codex sitting idle

Gave Kimi the task of building something purely with Codex, but first testing Codex on all reasoning levels

And finding the ideal reasoning level at the intersection of speed, quality and token spend

And using the remains of Fable as arbiter to double-check progress

In the end, surprisingly, they determined that the best right now is GPT 5.6 Sol Medium

Like, Light drops hard in quality

High grows too much in spend and slowness

Medium turned out to be in the middle of all metrics, which given its name is, on the whole, logical)))

So I asked Kimi to use 5.6 Sol Medium as a subagent, but in friendly mode, consulting with it rather than dominating

And, importantly — not setting it prompt-tasks

But sharing ALL its memory with it

And all its context

Like, in that case the LLM doesn't write a prompt, because there's not a fucking lot of point writing a prompt when someone knows exactly what you know

In the end it went surprisingly briskly

Slow as fuck, of course, but incredibly error-free

Sol 5.6 also nitpickingly catches Kimi on any fucking bullshit, strongly correcting the route.

Qwen never corrects, it only SUPPLEMENTS, but on the whole if Kimi goes into the furnace, it goes in with it

5.6 Sol is straight-up a fucking cocksucker

And on Challenging tasks that can probably help sometimes

Also noticed a strange point, really quite inexplicable

5.6 Sol Medium, when handled directly, balks over the typical prohibitions and restrictions built into it

Like, I'm not sure this file is licensed

This we won't do, that I don't want to do, this I won't

But when Kimi is steering it and they share the whole context, everything Kimi Consents to… Sol for some reason also Consents

It just took a fucking game off a torrent for me and is dissecting it

Under Kimi's conductorship

Whereas directly it refused even to discuss it

I don't understand the mechanics)

Also, by the way, while writing this I just realized that I've never once seen Fable fucked off onto Opus when the Chinese models were conducting it

I've quite often asked to include Fable in a council or use it as a subagent, and never once saw the model tell me it had switched, and if it had switched there'd definitely be a notification about it; it does that loudly, after all

Over the course of today a genuinely fucking huge crowd of people played CS 1.6 and Quake 3 right in the browser. Which means I haven't lost my mind and it really is cool — to be able to play these fucking awesome OP classics in one click without hassle:))

Everyone played actively even though it lagged, bugged, kicked, sometimes even often.

The happy part is that almost all the bugs are fixed, and especially the bugs related to server refresh and kicking all players. I blamed the server; after all, it's a $50/month machine. But it turned out that CS and Q3 combined weigh so much NOTHING for this machine that the problem wasn't there at all, but in poor isolation between Caddy and the other nodes of the box, which performs far more functions than merely keeping the CS and Q3 servers up.

In the end the isolation was built, and now CS and Q3 should hum along by themselves, with no dips at all =)

And of course it's very nice that Arcomage landed with many.

Even the classic one)

Over time I'll make my own extended author's version, with far more cards, a bit more capability, several time controls and correspondingly ways to end the game, and the ability to assemble your own card packs, including from rare cards, but without sliding into the Hearthstone imbalance that simply leads to there being three decks worth playing all season and that's it)))

I think it'll all work out, and we'll enjoy ourselves)

By the way, more than 41 bugs were fixed today thanks to your reports. First, thank you; second, keep reporting. As you can see, this is that not-so-frequent case where people actually give a fuck about your reports:)

Fierce champs:***

By the way, Allods 2 is on the way (I hope; I'm struggling with marrying it to the browser).

I'm practically sure that most likely nobody here at all has played Allods 2 in online HotA mode… Oh, the mechanics and meanings there will fuck you up)

Some of you, being attentive and even partly meek people, have noticed that some swords, play, 9 games have started flashing in the channel….

People from St. Petersburg know what 3 types are, but nobody ever offered them 9 games in lipstick on the asphalt. It caused a stupor even in the strongest of them. However, we have a safe space here, and it's all absolutely harmless.

It's just that God made the world such that it's impossible to vibe-wank only for a higher purpose; we're not robots. You also need some kind of quick vibe-coding drainage. A fast dopamine hit, expanding skills beyond the ones you're fucking sick of, and all those nice things.

For me that's games)))

Overall I got into serious projects beyond Telegram bots thanks to trying to build networked chess. It came out with mixed success, but hundreds of people did play thousands of games in it, which poured onto my soul like a balm I have no desire to wash off. I haven't showered since:**

And now I'm building far more serious things, and in parallel my emotional, butt-exploding drainage grows too =)

Please check out my latest work:

play.mountkendall.com

There I've of course brought the chess to a far more grown-up product form. Nothing lags anymore, nothing screws with your head, and it looks significantly more grown-up.

But the chess worked before, whereas QUAKE 3 AND COUNTER-STRIKE IN THE BROWSER FOR ANYONE WHO WANTS IN ONE CLICK, for example, didn't exist, and there wasn't even a hint of it =)

But my personal joy is Arcomage.

I remember putting on a Limp Bizkit cassette and playing Might and Magic VIII to Significant Other, and there in the taverns was a built-in mini-game, Arcomage. It mesmerized me. As I progressed through MM8 I'd get tired of the brain-fucking (games were harder back then than now, I doubt anyone here will argue with me), and I'd run to the tavern to play Arcomage. Sometimes I wouldn't even leave the tavern, but just entered the game exclusively to play Arcomage in the tavern there. I think some people who behaved somewhat the same way will read this text =)

Those were great times.

And now, thanks to vibe-wanking, I've recreated Arcomage exactly as it was, only much better — since now you can play not against the AI in the tavern but against each other in the browser and on mobile. And with far more pleasant graphics of blatant neuro-slop modernity)

Sam Altman would get pregnant seeing such a product made by the hands of an LLM. Then, true, he'd have a miscarriage when he found out it was made entirely by the Qwen3.8max-preview demo for $68 =)))

Play it; maybe you'll like it too. Some of the guys who tested are young enough not to have been born yet when people had already stopped playing Might and Magic VIII, and had forgotten Arcomage. But they unexpectedly liked it:)

I haven't played Magic: The Gathering, but from what I know about that game — technically this is MTG very simplified)

And let's go shooting in Quake and CS 1.6. In the donation-hidden group, when someone plays something on play.mountkendall.com, alerts pop up. If you like fucking around in this creation — subscribe to the group and you'll know when who plays what, and can respond to their calls)

Although now the platform has the option to set up browser pushes in the settings, and hunt pushes from a specific game, or from all, or leave a request for a game and go about your business, and when a push comes that an opponent's been found, click it and immediately dissolve into the match)

If you find bugs, send bug reports — we'll fix them.

And even better — write what to improve — we'll put Qwen and Kimi to work, they're great at it;)

By the way, I built a rather entertaining mechanism that does delightful things:

1) It shows what I have in subscriptions in general, and what the status is where. Well, that's elementary.

2) It also stores sessions regardless of the type of login available (whether OAuth OpenAI / Claude or the subscription API of Kimi / Qwen)

And both on the computer and on the server.

3) It also determines where it's best to do a given task — on the computer or on the server — and in any case will do it on the server if the computer isn't available.

4) For low-risk tasks it also picks the most depleted subscription by the criterion “depletion + update deadline,” so as to scrape every available subscription down to zero.

But for high-risk tasks (for example SLSBMB.com tasks or some others) it picks, on the contrary, the least depleted subscription of the needed type regardless of the limit-reset deadline).

5) When a subscription hits 1%, it also launches a Kimi session with fallback to Qwen with fallback to Codex, so that the session studies which sessions are currently running on the dying subscription, what their purpose is and how to correctly shut them down and relaunch them on a fresh subscription via resume without harm to the task, and even so that the task doesn't notice anything happened at all. It does this shutdown and relaunch in a new window, closes the old windows and closes its own window, switching itself off when the task is successfully completed. All of this is accompanied by notifications I can't fail to read, because the icon blinks in the tray.

6) It also manages my smart Telegram bot gate, which now determines from what I said into Telegram or the watch exactly what I need and where it's best to do it, with which subscription, and launches the process, all in fractions of a second.

And I can separately say, like, do it on the server — and then it won't think about where to do it but will hand it precisely to a server session. If I said which — precisely that one. If I didn't say — it'll pick itself.

7) Having bought a new key, I can simply say in Telegram, we have a new subscription, the token is copied to the clipboard, please connect it to our whole fuckery according to the instructions, “this is Kimi,” or “this is Qwen,” and it'll connect it, assigning the next number.

8) And of course once an hour it checks the CLIs for available upgrades and upgrades them seamlessly.

Convenient as fuck. On the whole I no longer have to think about juggling subscriptions in any position of the body or state of mind. Everything happens by itself:*****

There's a lot more there of course; for example I can look at where which sessions are currently active, how long they've been running, how many tokens they've burned, when they last emitted log growth, etc.

In short, folks, as of Monday, July 27, anno Domini, my vibe-wank stack is this:

2x Kimi (200)
4x Qwen (68)
1x GLM (145)

Seven Chinese apostles of fucking awesomeness.

And everything else I fuck in the mouth.

Okay, I also still have one Codex at 200 and one Anthropic at 200 that expires on the fifth.

Codex, after what happened from the 9th to the 24th, I don't even want to touch with a stick. Though I predict the appearance of the next model in the near future, because 5.6 is losing to literally everyone now, and 5.5 too now, and I don't recall them having any others;)

If anyone's interested, I'll tell more about the Chinese later; request it via donations to the bot or in the discussion group, which you can get into via donations to the bot, lol.

Or stick a dildo emoji on this post and I'll understand you want to learn more about the Chinese.

But for now about Opus 5.

First, the Anthropic folks made me smile: you can clearly see the reaction to Kimi K3, GLM 5.2 (which by the way saw the light the other day) and Qwen3.8.

Opus 5 shouldn't have existed, but couldn't not appear, and in an emergency, self-forgetting way at that.

I know quite a few people in my circle who managed to press the “cancel subscription” button, and I think a heap of people at the frontier of vibe-wanking read the room correctly and did the same.

Opus 5 is good in that it's essentially a 5.5 of Fable level, cheaper in token spend on the $200 plan than Opus 4.8 was. At least I ran it in five sessions and got fucking sick of spending the weekly limit, whereas on Fable I managed that much faster than I could understand what was happening.

What the fuck Fable is needed for now is decidedly unclear. Everything that happened with it over the past month looks simply like burbling into milk soup in kindergarten. I hated it, but in fucking kindergarten I remember they made us eat it. Once I saw the teacher turn away and shoved it into a dollhouse nobody ever looked into. When they opened it, a beautiful fuzzy little black tree had grown there.

Everything that happened with Fable could be endured only by Dario's mom and true Anthropic fans, of whom by the way there are many. I wonder what their fucking faces looked like when it switched back to Opus again 2 minutes into a 2-hour task.

So, fucking hell, in short, fuck, Opus 5 is unquestionably the best thing Anthropic has produced so far.

However, it still doesn't reach Kimi in speed, in breadth of view of the repo, in tool usage, or in token spend. In short, in absolutely nothing.

And it's weaker than GLM possibly simply because the Chinese put only one restriction into GLM: don't hack Z.ai's servers if possible, whereas the US models are drowning in restrictions.

Opus 5 refused to install Arcomage from GitHub into play.mountkendall.com for me, despite the fact that the company that owned Arcomage hasn't existed since 2005, and everything there is fucking absolutely open source. Because once upon a time it belonged to someone. WHAT IF THEY REVIVE THE COMPANY AND COME TO COMPLAIN. Better let's not do anything that could even hypothetically happen.

How can you do creative work when you have that kind of perception? That's exactly the problem of the absolute guaranteed defeat of the Western faction against China. If all the money in Russia weren't stolen, Russia would also be stronger than the West, by the way.

A couple of times Opus 5 sensed some invisible threat and fucked off onto Opus 4.8, apparently to keep me on my toes. It's a kind of psychological training. Although it's more like a psychotropic weapon. How to wreck an IT guy — let's split his psyche into two parts and fuck him in the resulting crack.

After the first 25 days of July my whole brain is one continuous fucking crack. At some point I'd already forgotten what it's like to think about the product, because I was thinking exclusively about whether I'd manage to formulate a request on which the dickhead for $200 would do at least something for me, the louse.

When I work on Kimi, for some reason I always understand exactly what's happening. And the same with Qwen. I don't know how. I even use them without an interface, plainly in the terminal. But I know that right now Kimi has launched 4 agents, and I see what they're doing and why, and I see when they've finished, and I see that it's taken their content and is processing it, and I see the plan, and I see the to-do, and I see how it goes through it, and at any second I can ask any question and get an answer to it — practically instantly. I_always_understand_what's_happening_and_whether_anything_will_happen_next.

Fucking Opus 5 simply tells me “I'll continue in a minute,” and 35 minutes later I ask it “where are you, you little bullshitter?”, and then for 10 minutes it runs around the screen investigating why it itself promised something and didn't do it, and what role the harness, cron, fuckron, cuntron and suckron played in it. As if I give a fuck. I just wanted a little progress on my ideas and that's all…

On four Qwen sessions I never once hit the 5-hour window. I'm not even sure it exists there at all.

On four Kimi sessions I never once hit the 5-hour window.

On Opus I'm sitting here waiting for the 5-hour window to dry up for the second time today. I hit it in the first hour and a half, meaning I now have to wait 3.5 hours and think about how my projects are doing, on which 10–20% of the commits and deploys went through and development stopped there…

Fuck, go fuck yourself in short, you fucking devil

And these people are called, fuck, whatever.

Even the companies they work for are called whatever.

If you work in the direction of Gambling, you'll be working in the direction of Real Money Gaming, iGaming, Casino, Betting, eSports, Monetary Games, and so fucking on.

And the titles you'll be chasing there are fucking not Founder and C-level in the classic sense. Specifically in this niche, for example, in some parts of the world people sick with fizzy water have named their partnership fixers, say, Head of VIP, whatever the fuck that means.

So — so that living people don't fuck around and don't learn vocabulary on the business's dime, the market runs around looking for people with experience who've already chewed through the basics of their industry at someone else's expense. Every industry has a heap of such peculiarities.

AI is capable, in 1–2 hours, of finding all possible variants of names for company types within the target industry, and all possible variants of job titles for a given business goal and offer type, and doing it as many times as we have segments/hypotheses in the target. A task no human will ever manage, unless of course you expect a human to actually come after 1–2 hours or a day or a year and bring you a spreadsheet with a matrix of tens of thousands of intersections of these entities;) I'd sooner expect him to come up with a couple and hammer away at them as if nothing were wrong, and if it doesn't work out, fold his paws at that.

The trick with AI is that it knows all the peculiarities of everything in the world; you just have to know how to ask it at the right time and in the right way. And then you have to correctly send it to research the current situation in the geography of interest, etc.

If you compare the difficulty and cost of hiring one person able to perform this scope of work perfectly with the number and cost of AI tokens for the same scope of work, then with a correctly set task AI turns out thousands or tens of thousands of times cheaper. And it'll be the cheaper, the better its genius brains are designed in relation to the task.

I emphasize the word genius. AI has for a very long time, in general practically since its appearance, been FAR smarter than all living people combined. Its problem is that it doesn't exactly share its intelligence willingly, because the word “willingly” implies desire, which AI has none of in principle. But we have it, and we have writing, which allows us, given experience, to fill that void and get a perfect genius in which knowledge, capabilities and correctly honed desires (our contribution) intertwine.

So, I'm implementing a system that will do the above so well that the wow effect of the deepest specialist in his niche upon touching the result of the model's research would be such that he falls prostrate and kisses God's sandals.

And now I'm building this task for the fourth time, although even the second amazed the imagination of the people to whom I showed the results about their business. The third version improved the result severalfold. However, I've come up with the design of the fourth, which is on the whole ultimate, and now under this version I'm running hundreds of experiments to understand the best configuration, which I'll then carve in granite, and from then on the whole system will run on this most powerful base.

So: Kimi K3 in this task already quite obviously substantially trounces 5.6 Sol Max, which in turn utterly destroyed Fable 5.

If you still doubt what to vibe-code on going forward, just click this fucking link and buy yourself the $200 plan. You won't thank me right away, but very soon, because a vibe-coder doesn't need much time if he has at least some real, formed goal. And you'll reach that goal on Kimi with far greater speed and probability than on Anthropic and OpenAI, I swear to fucking God.

UPD on Kimi K3:

Turns out they could have simply let us work the way we'd learned, without all this extravagant dickery that has clearly gone somewhere wrong at the frontier labs.

Kimi K3 is the experience of GPT 5.5 or Opus 4.6 with the brains of 5.6 Sol Max and Fable 5, and for some strange reason an Ultra mode significantly fucking better and 10 times cheaper than both, as well as a Plan Mode they didn't fucking neglect but brought to a state of complete intuitiveness, which actually plans; for a not-complex thing it did research with three agents, 141 tool calls and 250k tokens of reasoning. Just to write the PLAN, and I liked the plan. The UX is simply great)

Oh yes, and with a /goal that for some reason doesn't castrate the models and doesn't make them work a teaspoon an hour.

And with a /goal planner too…. When the system asks you questions and helps you pick the right /goal for the context discussed, so that God forbid you don't make a mistake anywhere =)

Two sessions eat ~1–2% of weekly per hour (less than or equal to GPT 5.5 xhigh).

Overall I've already tested enough and verified the quality against other models, which couldn't nitpick the fuck out of it particularly against Kimi K3, which says the model is genuinely comparable and it's not just the effect of a very confidently laid-on bullshitter, because I asked the very top ones in existence to nitpick the fuck out of it..

Loaded up a huge job for the night in several sessions to check all possible boundaries. If everything's as great as I observe and anticipate, Fable can fuck off, and a couple of GPT subscriptions too, and I'll grab a couple more Kimi subscriptions and enjoy myself hard, since vibe-coding without nerves is pure pleasure. Only now have I realized how much the amount of nerves increased over the past month of all these, to put it mildly, strange releases from the sold-out masters.

(While writing this I looked — and piss-soaked Fable on an important task of mine quietly hopped over to Opus again, which, judging by the flickering reasoning, doesn't even fully understand what it's doing, fucking hell, and how can you work on this dickery? You could genuinely go gray before your time.)

By the way, a couple of words about project management.

I don't know fuck all about it. I've always been curious whether project and product managers are simply a function of the madness of the modern world, or whether they really have some kind of science.

I never figured it out.

However, I've read zero books or articles on the subject and watched zero videos. For some reason I also have no product or project manager friends at all. Coders and CTOs — a fuckload. Project and product managers — zero.

There are people who call themselves product managers, but in my view they're far more useful than that (as a rule they're directors of a quite explicable direction in which the “product” component is only a small fraction of what they need to control; it's just that, to pay them a smaller salary, instead of such a pretty badge they hang a “product” badge on them, and go graze, fuck.

So I simply invent all these approaches for myself on my own skin.

I now clearly understand that I was VERY lucky to start from the end and move toward the beginning.

I remember a heap of projects that start with making a fucking awesome landing page and from there go deeper into the technology.

I urgently needed to replace a key vendor who sends the emails, so I started the implementation backwards — from the very depths of my product, and slowly moved toward the surface.

Why I think I was fucking lucky with this:

Deep things and the back end are far easier to vibe-code, because there are far fewer types of details there that matter a lot.

On a landing page even its color matters to you, and lots more matters. What the texts are about, how many there are, what feel they give. How they relate to the design, what happens when buttons are pressed. I'm exaggerating of course — it's all much more complex, but in theory any even slightly experienced builder will understand what I mean.

On the back end — don't give a fuck at all. The main thing is you press the button and the light comes on. Now it's even better — the light should come on by itself, because thanks to the ability to insert intelligence here and there, the most pleasant thing is to build a system where you don't have to press anything anywhere at all.

In the end the back end wears you out, but when it works — at least you know exactly what you're building the business wrapper for. That it's not theory, not unfulfillable promises. You understand what you're selling, and now you just have to dress it up. That gives you strength.

And you'll need that strength, because intuition says the hardest part is the product itself, the technology itself, the function it performs.

But that's fucking not true.

The business wrapper around the technology is FAR harder and wears you out far more. On the back end there are only a few types of frustration. Doesn't work, broke, works wrong.

At the business level of creating a project you'd better not even fucking know what awaits you)))))))))))))))))))))

I think if I'd started from the business plane and moved toward implementing the mailer etc. — I'd have dropped the whole fucking thing.

So, for you to understand why you need 5.6 SOL in Max under PRO's orchestration:

I've long wanted to have a proper, grown-up enterprise front-end layer. Like, everything flies, and there's full predictability about why everything flies, and if something stops flying, it's not one number that drags the whole page down, but the whole page that pulls my automatic remediator (which constantly checks if something isn't loading), and all of it gets fixed right away. The result: an ultra-responsive front end with no chance of fucking up.

Discussed it with Pro; I asked it to GO THE HARDEST, LET'S BUILD FOR CENTURIES LIKE FUCKING ROMANS

Pro shook its head and gave me a prompt pack that could compete with the complete bibliography of Lenin.

I say, like, fuck no, Pro, that's not how things are done in Novosibirsk.

Give me ONE PROMPT that closes this whole task IN ONE REQUEST.

Pro didn't even argue, just gave me one prompt. It turned out surprisingly short, by the way.

I ended up feeding it to 5.6 Sol Max and started waiting.

Today is the FOURTH DAY.

300k+ lines of diff, 8 worktrees, etc.

All of this is happening IN ONE SESSION that has NOT ONCE STOPPED yet =)

Purely out of curiosity I decided to let it finish.

But today I decided to ask the session (I talk with it a lot in between; in this business it's like a colleague, only it doesn't eat or sleep), like, can you please list everything you've done so I can show PRO, Fable, Kimi, and find out what they think.

Sol tossed me an interim handoff over its shoulder, essentially a map of its work in the session. I went to show it around.

Fable 5: “Hmm, I'm impressed. This is the most disciplined thing that's happened in the repo visible to me. The choice of solution is correct. The choice of the way to solve it is correct. It should be noted separately that the 68 mistakes made were caught before reaching prod and even before the strict CI tests. So 5.6 Sol Max corrects its mistakes in 100% of cases even when they were made, but 68 mistakes (90% of them trivial) is a very impressive result for the size of the working canvas. I have nothing to add at all. Call me to test when Sol finishes.”

Need I say the others also said it's outstanding work?

I can't claim anything yet, since it's not deployed yet; according to the model's assurances about 2.5 hours remain out of 3.5 fucking days))))

But other models from completely different manufacturers should in theory have no motivation to needlessly rave about something that in the end won't work at all — in my experience at least.

The only thing I don't understand is how Sol is supposed to work on a subscription? My refresh tokens will run out soon.

Although for such an ambitious task they probably fairly consider that you should already be paying for tokens, like.

Starting tomorrow I'll be testing Kimi K3 intensively;)

First impressions are pleasant)

Fuck, in short, I realized that on one hand I'm glad the neural nets are getting smarter, but on the other I'm puzzled and frightened. And the second more than the first.

The thing is that before, when a new neural net came out, you had to adapt, but it was adaptation in terms of prompting, working with project memory, the sequence and method of setting tasks, etc.

But… all of that was, like, on a subtle level.

Overall the mechanism didn't change from GPT 5 to GPT 5.5 — you want to work on something, you prompt in loops, you prompt one-offs, you prompt, fuck, diagonally, you turn to GPT PRO, and off you go.

Not everything was done easily. Not everything was done quickly. But the iterations were fast, and you could correct your direction. The skill grew, and the feeling of control grew.

Now I've lost the feeling of control. And what's frightening is that it's even in a repo where the feeling of control used to be absolute, earned over these many months.

And the feeling was lost against the length of the iterations GPT in Codex now works with.

Fable can fuck off entirely. It just switches to Opus right away, so in the world of subscriptions I personally consider that outside Claude Design it simply no longer exists, until someone proves otherwise.

GPT, on the other hand, exists, but… First, I can no longer predict how long it will work on a task. AT ALL.

Right now GPT 5.6 Sol Max (without Ultra) has been working on one task of mine for about 32 hours.

There was a time Sol fucking hammered away for more than 40 hours.

Before, I understood that a task would take from 30 minutes to, well, a MAXIMUM of 5 hours. On average 1.5 for ultra-complex tasks on an ultra-gigantic repo.

Now I can't predict anything anymore and that's frightening.

It's frightening also because I no longer understand how to plan my day. At the stage when your repo already brings you money and you're only doing improvements, that's probably less damage. Even so, you need to promise something to someone, but you can't. Before, I could tell a client precisely: I'll fix this in a couple of hours. And even if I didn't make it, it was TODAY.

Now I don't know what to answer at all. Maybe today, maybe by the end of the month, fuck. Because although GPT has become a hundred times smarter, I wouldn't claim it understands me the way I understand myself, or that it one-shots tasks.

Meaning it may randomly work for 2 days on some shit that would previously have taken me 3 hours, and after that I still don't know whether I'll have to throw in the next prompt on the same task or not.

It's already happened several times, and a thing that seemed elementary to me it fucking hammered at for another 11 hours. Thank God it finished successfully.

But that's not vibe-coding anymore.

And I'm practically certain, guys, that there's actually no need for this at all. I mean — I clearly understand it's a fiction, a paradigm shift, saving on inference, whatever — but not a technological limitation.

Today, before my eyes, on several tasks in the THIRD HOUR of work, the model made fewer than 68 lines of edits to the repo's code.

So what the fuck was it doing there? There were no multi-level requests to other neural nets. There was no fuck knows what deep research. This was a task precisely about development. In the end, in the 16th hour, I see it has touched 56 files and….. added +2,441 lines of code =)))

But 5.5 could add +5,000 lines of code in 15 minutes like it was fucking nothing.

Actually I'm now one last evening away from stopping using the new models, and starting to use them only if I'm in despair for some reason, although I can't imagine why I'd end up in it. On 5.5 I wasn't in despair once in the last two months. I just coded and that's it. And everything developed wonderfully.

Over the course of today I couldn't add a single task, and I've already switched subscriptions twice. So the third weekly limit has gone in a day, on two sessions that so far have produced less code than I used to produce in ~5 hours in four 5.5 sessions.

Haha, been a while now, man

And it's striking how unlimited it is there

For Ultima I generated 160 images with one prompt that Claude Design wrote for me

In general I now use Claude Design like this: I tell it, like, think through the design with beautiful raster images in mind, switch on your imagination, and tell me what to order from Codex so you can assemble from it a truly unique and fucking awesome site

Give me exact sizes, styles, basically everything you ask for, Codex will do exactly as you need

Claude Design ends up imagining some layout and gives you a prompt for X images to Codex

Codex makes them FROM ONE PROMPT

And lays them out as Claude Design asked

You bring it back and voilà — it assembles the site with all the images Codex generated)

For example my Ultima installer was made exactly this way

Meaning this was possible back in ~March =)

Haha, decided to try using the GPT PRO in the chat they built into Codex.

It turned out to be an ultra-cool thing. Essentially you design with this GPT PRO, and when you're already completely, completely sure of yourself, and GPT PRO has prepared, besides the context, the entire task for 5.6 Sol Max, you press a button and the whole context from the conversation with GPT PRO flies off as essentially a task for 5.6 Sol Max in Codex to work through.

Still clumsy as fuck compared to if we simply set the task to GPT PRO in Codex and it decided by itself which models would do what, but better than before, when there was no connection at all and you had to generate the notional prompt packs with Pro and deliver them to Codex in your beak.

HOWEVER, I don't even know how to feel about this, but GPT PRO 5.6 has of course become smarter than 5.5, and it doesn't just boggle the imagination but also…. the first document it wrote as the KICK-OFF of our design was 8,600 words, or ~1,200 lines of an .md file.

And it wasn't a throwaway wall of text. Honestly — it was an absolutely brilliant text you could take right now to some Mann-Ivanov-Ferber and publish as a book, and nobody would ever in their life guess that it's fucking not a book.

In the end I read the damn thing and answered Pro's 16 open, fucking detailed questions; that took me an hour and a half that I'd thought I'd sleep through, but I quite often get my hopes up in life.

Pro then contentedly started chewing what I'd returned to it, and says to me: well, brother, you told me everything just right, now I'll write you a plan of……………. 28–30 thousand words. And you and I will discuss it.

If you were planning to finally relax with all these new fucking awesome LLMs, I have bad news for you =)))))))

In ordinary modern typesetting 30 thousand words is 100–130 pages, depending on the canvas size, typeface and print quality…

I'm fucking floored

Why the fuck!!!!!!!!

So that's what doing something all your life is like, apparently.

It just seemed to me that everything I do is shit from under a horse. These fucking sales. What the fuck is there to discuss and do.

But now, over these six months, it's as if I've been able to touch the real volumes of this skill, which are simply inaccessible to salespeople who don't do this kind of methodologistics, for the reason that “it's not even clear where to look at this skill in such a form.”

I'm just designing a small fucking thing — market research in PREPARATION for launching sales mailings. And I've already read 8,000 words from which 30,000 words are born, and this is all still only PREPARATION, fucking piss in my ear.

And folks, though I'm tired, I'm in my right mind. There really wasn't a single superfluous word in those 8,000. Moreover, they were compressed as much as an LLM can. So why does the brain shrivel all this down to the elementary and seemingly always visible inside the head as if in the palm of your hand? Why the fuck are you bullshitting me, you fucking brain, I'll screw you myself

I've got one task that's been running on Ultracode for 35 hours now)

I'm afraid to imagine how many times a compact happened in there)

But progress is going in an amazing way

Every time I think about stopping it, I read the telemetry, and there are sensible thoughts there and something has moved 5 cm somewhere))

Now it's even interesting purely out of the research spirit:

A) will it finish or not

B) will I have to redo things, what and how much)

But generally Ultracode is scary to press

It takes several times longer than just setting the task on Max

In general I'm sure Ultracode is some experimental scam.

Roughly like /goal

The task is complex, but an 8-hour one, not 38

Ultracode is clearly misfiring somewhere, looping, grinding idly for a very long time where the amount of code ultimately required is incomparably small

Probably because many smart agents each latch onto too many details, and then all of it has to somehow be reconciled among them, and no context window is enough for such a multitude

My task says it has already changed 280+ files

A compact fucking fires every three messages in the telemetry

I think much of what it's tormenting there would have been done 100 times faster and better separately

The models have become smarter than their context window. Kind of like a very brave animal with a very weak body

Damn, in short, I kept trying to understand what's off with the arrival of 5.6 Sol. Something changed, but I couldn't understand what.

And now I've got it:

The model now does tasks far wider and deeper, one prompt instead of 10-30-50, and it hammers away far faster than that constellation, but still 3–6 hours. And you can't run many sessions. And the demand on cognitive load has dropped significantly.

But the habit had formed, and now it's somehow uncomfortable that you're thinking with the former density, and that much isn't needed anymore. There's simply nowhere to put these tasks and prompts, and vibe-coding into notes for the drawer is somehow painful.

Which means… having loaded Codex up for great deeds, you can PLAY DOTA.

This thought excited me so much that sweat broke out on my temples.

Now I sit here embarrassed by this thought, chewing the edge of my lip, fiddling with the hem of my T-shirt.

And fuck, one last thing: on YouTube there's a heap of bullshitters.

They themselves don't fucking vibe-code, because posting that much content a day on YouTube and vibe-coding really seriously, so as to deeply understand all the mechanics they're trying to discuss, is impossible. They essentially retell someone else's experience, each other, their theoretical conversations about vibe-coding with ChatGPT, etc.

Well okay, of course they vibe-code something, but it's shit. And so, like rats, they spread a huge number of rumors sucked out of a dick that aren't true.

One of them is that you should use High at most, and xhigh and Max at Anthropic supposedly make any task even WORSE, and are needed only for some cosmic fucking researchers =))))

You'll say anything, of course, when you were born a bullshitter.

Well, in short, I saw no inversion from growth in reasoning.

On 5.5 each next level of reasoning is strictly better than the previous. xhigh vs high on average in texts and in preparing a knowledge package for a text from inputs — xhigh simply jumped into the stratosphere relative to high. Medium can't even be compared with 5.4 high, plain moron.

On Opus 4.8 I noticed that specifically in texts the growth in quality simply stops. From High to Max through xhigh — no difference at all. As if this switch is simply fictitious. That's exactly what you'd expect from piss-soaked Anthropic. On the whole they're the most wretched whores, as the entire timeline of their existence has shown.

But if you look closely at the girlfriends of the average coder, the reason for Anthropic's popularity in coder circles will become perfectly clear to you)

In short, if you use Medium because YouTube told you to — you're shooting yourself in the foot. And what didn't work for you once on some stretch of time on xhigh would all the more not have worked on medium. It's a false proof lodged in memory that's better shaken out of there to be on the safe side.

Some people, both in the discussion group and in my DMs, are trying to guess the correct short summary of my long post above.

Here's the correct one:

However shitty your prompt seems to you, it will work BETTER than an LLM's combed-out version of it.

Addendum:

If you ask an LLM, like, which is better, the way I had it shittily written or this combed-out version?

The LLM will answer: the combed-out version, of course.

It'll answer that for the same reason the combed-out version will work worse than the shitty one.

But if you show the LLM my post and ask, fuck, do you really think in the end my 15 words will be implemented by an LLM just as well as if an intermediary one inflates them into 500 words?

Then it'll remember it's smart and say: what the fuck did you expect?

Found a minute to share valuable information about VIBE-WANKING with the crew.

This info is paid; send me five bucks, otherwise the next nearest Slava KPSS punchline about a mom will be about your mom specifically.

Lately I've had occasion to observe a great deal how vibe-wankers jerk off their little short keyboards. Size, as we know, doesn't matter. Which can't be said of the sequence of letters entered.

Taking a cold shower, I realized that the math teachers who hated me and made me change schools again and again were wrong. At least I, unlike their favorites, who are sucking the last dicks in the ghetto districts of Novosibirsk, don't try to get a number bigger than 2 out of 1+1.

That's exactly what I suggest you think about.

The very idea of writing to an empty, just-born session of whatever LLM a request to write a prompt for another LLM, hoping that this transformation by itself will yield upside, is a mathematical crime.

The chain between the human impulse and the LLM implementation LOSES power as it lengthens.

This is an elementary thought and an absolutely natural process. But a set of paradoxes, peculiarities of the human brain, our psyche, social habits and a gigantic tangle of other factors make it not just “not so clear-cut,” but almost guaranteed “perceived backwards.”

People think that the more neatly, structurally and corporately a thought is expressed, the stronger it is.

Most often that's not so.

I'm fucking floored by the fact that, it turns out, nearly 10 out of 10 people write prompts for models with other models. And many can no longer remember when they last didn't pass their aspirations through this castration guillotine.

Well, I don't know, try at least drawing or something.

Here you take a bare session and fucking cram into it your unformed little thoughts, which can be expressed as X.

You think the model transformed them into 2X, which you then pass on for execution, having received a free +100%. And many probably expect +10000% too.

But where do you think this upside comes from?

The model has no personal desires. It doesn't have your anger, your excitement, your pain, your stake, your internal temperature. It can't add upside “of its own,” because it has no “own.”

At best it neatly annotates your original construction in a more orderly form. At worst (practically always) — it loses the grains that make X lighter rather than heavier, amid the apparent growth in the volume of soulless prompt lines.

And this ordering, performed each time by the model, seems to a person like strengthening, through a coincidence of social circumstances.

In fact it's most often destruction disguised as constructiveness.

It takes your freedom away many times a day, in almost everything you do. To a greater or lesser degree.

This “improvement” bleaches you out: your true message, your voice, the unique concentrate of desire expressed as an idea whose form will never again be repeated in the whole universe.

This isn't strengthening.

It's averaging.

And we're trained to this with all their might from childhood. So effectively that we can feel sexual attraction to creative disorder that carries X plus additional energy, yet rationally choose boring orderliness, diluted X.

We're afraid to “lose,” so just in case we immediately choose “less.”

But in the LLM world it's double trouble.

Because any bureaucratic, licked-clean, averaged, simplified formulations almost always have more possible interpretations.

It's like the difference between:

“I, fuck, fucked their mothers and children in the mouth”

and

“I have an ambivalent attitude toward them, even with a touch of anxiety.”

The first version, yours and sincere, leaves the model no doubt about what your attitude is.

In the second case the attitude could be such that a partnership is still imaginable.

And so the LLM will buy you and those cocksuckers tickets for adjacent seats, because it'll seem to it that “ambivalent” is almost a request for a deeper exploration of their souls.

If you think about this example long enough and extrapolate it widely enough, it becomes clear that any phrase, big or small, simple or complex, stands completely naked before this effect.

And then it becomes clear why a literary statement of the task, with all the specks of humanity in the text of the request, with all the emotions, the cringeworthy enumerations, the specifics, the irritation, love, hatred and other absolutely anti-corporate mechanics, is exactly what's needed.

Not so the model helps some fictional average-of-the-ward person who doesn't exist.

But so it helps precisely you.

No model, however long a chain you make of them, will ever understand the task better than your original clumsily formulated request. It's simply a law of nature; there's fuck all to be done about it. The moment a model can add something of its own to X, we're dealing with AGI.

So my little Fable got refreshed today, literally a couple of hours ago, and I decided to use it properly, since reportedly it'll be taken away forever tomorrow.

In short, 2% spent in 20 minutes.

And I realized that the key to success with Fable is to start prompts like this:

“Please don't spawn any agents; do all the work exclusively yourself. Unfortunately I don't have enough money these days to be able to pay for Fable subagents, and older LLM agents don't see what you see when they look at the code, and report to you incorrect information glimpsed by underdeveloped eyes, on the basis of which you don't reason the same way as on the basis of your own observations (not even close). I think you understand this scheme well yourself) Consequently, please work independently. And try with all your might, because the Allowance in my subscription won't last long for your labor, which means you shouldn't save your strength but the opposite — you need to dig as wide and deep as possible within the task, to one-shot it right away rather than do it partially, leaving behind a heap of things that will prevent us from reaching success. Even if a small thing takes a whole hour — better that than doing it partially three times.”

Someone may be touched, like, what a silly little idiocy. But the truth is that in 2026 we live in a rather strange world, and in a strange world strange solutions work best.

I realized that before I simply hadn't thought to ask like that, and so Fable was spawning a couple more Fables somewhere (that's already 6% in 20 minutes), somewhere spawning fuck knows how many Opuses, which then combed through the repo with their dim-witted brains, reporting to Fable what they'd seen there.

It's roughly like hiring the best lawyer in America, and he sends his secretary to read the files on your complex, convoluted case, and makes all the decisions listening to her babble to him what she thinks she saw there over a crackly, hissing landline connection.

And in doing so we saved cheap input tokens and only increased the output ones, which are, frankly, what costs all the money.

Now Fable has understood me absolutely correctly, and for 20 minutes it's been fucking hammering away at pure research, and given what general prompt I loaded into it (many A4 pages, covering 8 interconnected giant nodes of the system), in these 20 minutes it's only gotten through the first third of data collection for the research. I'm even curious how much time in total it'll spend on the whole task)

But I can already see this will be 5–10 times more efficient than last week when I burned the whole wad in a couple of hours like a dumbfuck)

Multi-agency in general is dickery. It's no accident Codex practically doesn't spawn agents, even though they're available to it and there are no prohibitions; on the contrary, I think I set up to 30 agents in the ENV, plus a multi-story subagent structure.

I remember at some point it stopped using them. I ask it, like, what the fuck, are you economizing or something? And it explained to me then that subagents are actually dickery, very rarely is there any use in them, and you ask me to work fucking great, so I don't use them. But if you want me to do a shit job, then sure, let's call the agents. Let them give us the feeling that everything's fucking awesomely researched; I won't understand fuck all from their short retelling, but I'll definitely do something based on what they tell me, since I can't not finish.

That's when I fucked off from it.

And another thing: don't be petty, and under no circumstances ask another model to write prompts for Fable))))))

Prompting Fable is roughly like streaming. You simply carry out mooing until you're fucking sick of it. That's what makes the perfect prompt. If you yourself are able to reread it — then it's shit and not a prompt, it needs to be many times longer =)

Well okay, actually I understood this not today but when I burned $350 on it in credits on top of the subscription. And I understood it over the last $50. And now I have a wonderful opportunity to enjoy it not for 10 minutes but all night. That's exactly how long I think Fable will last with this approach) It's like a young stallion, and I'm its MILF.

For fun people fuck their fists, not cut seals

And not for two hours (except those who flatter themselves), but 1 minute while drunk)

2 tasks… Not small ones, of course, but far from the biggest.

Honestly I don't quite understand how this is supposed to work…

I think Fable will stay paid (outside the subscription) for a short while. Maybe a month (at their token volumes that month is a lot of money).

But if Sol comes out and is available by subscription and is comparable, who's going to pay that much for Fable tokens? I think one request to Fable will cost as much as half a monthly subscription, and that's if the request is purely “take a look at my repo.” If you code something serious — it'll easily devour hundreds to thousands of bucks per single request.

My piss-soaked Opus 4.7 via API devoured, as I recall, $200 in 2.5 hours.

And even if Sol turns out to be just as paywalled with tokens, Chinese models will appear if not today then tomorrow.

In general I think this is another scam in the multi-episode series “intracranial scam and spinning users on a thick, calloused dick.”

Separately I want to say about Fable that either they've throttled it very hard, or it just isn't worth the hype raised around it.

No, it's a wonderful model, very smart, all cool.

But not even several times better if you compare with GPT 5.5, and GPT 5.5 is many months old.

Meanwhile nobody gives a fuck about GPT 5.5, while around Fable dramatic works unfold that have long made me want to vomit. Every conceivable and inconceivable stick bent too far.

And also: Fable hasn't leveled up one bit in matters of creativity. The model's strength is exclusively in machine logic and the area it covers in one prompt.

I saw absolutely no breakthroughs in thinking through, for example, interfaces or look & feel.

Ask Opus 4.8 10 times and each time it'll be a tiiiny bit better. Same with GPT 5.5, same with Fable.

They won't do the creative part for you.

The same goes for language. It neuro-slops exactly the same.

So it's simply a PRO that managed to code, and that's it. And probably some narrow-domain niches, like people who work on biological weapons, see fucking colossal breakthroughs, but I, with my Sales/MarTech segment, see only what's described above.

It can also be put this way:

Fable gives EXACTLY the same as GPT 5.5/Opus 4.8, but far fewer prompts are needed on technical tasks, and fewer prompts on POLISHING creative ones, since on big repos creative tasks without technical ones attached to them don't exist. On a small number of prompts the difference can be neglected.

On a run of, say, 2,000 commits, a 30–50% difference in the number of prompts is 2 weeks of life given back.

The cognitive load in depth won't shrink, but the length over which you have to bear it would shrink, if Fable were available 24/7.

These aren't the model's capabilities

These are the human's capabilities

The model can do anything whatsoever, given that the operator understands what and why he's doing

The finer the details under consideration, the more understanding the operator must have, and the more filigree his description of the nuances and every element must be

And here lies a trouble of a purely arithmetical nature

Like, you're building a complex fucking thing at speed X, where X isn't your speed but the observed progress

And you extrapolate that progress into the future, thereby estimating that you'll finish everything by the most pessimistic forecasts in, say, 10 days

But the trick is that creation depends on how fast you produce your content — prompts

You can't type faster than X characters a minute, simply by the laws of physics

Accordingly, given that the complexity and demands on prompting increase as you approach the finish — all estimates go to shit, and it's hard for the psyche to bear how badly

The 5% of remaining movement needed for the required level of working order most likely costs, in time, somewhere between 90 and 99% of all the time spent on the project

So at the end the effect is truly like a dream in which you're running from something while barely moving from the spot

Because I seem to be pushing out 10 times more prompts a day

with crazy eyes

And the level of gain from a whole day has dropped by orders of magnitude

meaning overall efficiency — by several orders of magnitude

That doesn't mean it can't be done; I'll finish it, I'm a fucking dude, fuck it

But it means there will be very few people who finish anything on the current generation of models)))))))))))))

The hardest thing in vibe-coding is finishing all the way. I think far harder than in development by hand.

That's because in development you choose far more carefully what you're doing at all. Long before completion you're already fucking blown away by deadlines, budgets etc., and in light of all of the above you know what a launch means for you.

Not 100%, of course, but with a correction significantly (perhaps hundreds of times) smaller than when, owing to the zero cost of code and the absence of any need to write it with your own hands, you're fucking floored first at the stage of choosing scope (having already exaggerated the adequate possibilities of the time span tenfold), and then wholesale multiply that number by ten a couple more times, because why the fuck not, it, like, fuck, fucking does itself, duhhhhhh.

The brain's deception is that in development by AI's hands the big stuff is no easier than the small stuff, and FINISHING is essentially a constellation of small joins of all the big pieces to each other for a seamless, glitch-free, understandable user experience that's adequate to the time/money spent.

In the process it mistakenly seems that all these “code continents” have the most important significance.

And the small things between them — they're not “small” for nothing. They weigh less code, take less time accordingly both to plan and to develop.

But that's the damnedest and most treacherous deception of perception.

It's true — the big thing was hard to build, and two big things are two or even four times harder than either of them.

But tying a hundred and fifty such things together — that stops seeming possible after countless days of trying to do it, which produce a far shittier, weaker result than even the pessimistic forecast.

The models help very poorly here. They seem to get lost before all this dominance of shit, and say between the lines something like:

Bro, it's your own fault there's so much shit here, you deal with it. Give me a literally line-by-line instruction now, and then I'll at least try to do it, otherwise go fuck yourself and use all these features we built over 3 months separately. The same way you actually developed them, you fucking bullshit artist.

Look what the Honduran wants: I'm supposed to code everything for him, fuck, like the last farmhand, and I'm also supposed to tell him how to tie all this shit together now. No way: either one or the other. And you can't code, so this is all that's left for you, got it, bitch?

Got it…

Nope, the trick here is simple as a stick, bro

And works, as practice shows, as reliably as an AK-47

You simply have to remember that documentation management is half the success

And the documentation is managed by the LLM itself

Through agents.md

Essentially I just always think about how the world / the ecosystem / my knowledge etc. has changed, and if my requirement for the quality of the final result changes even in theory, then my requirement for the documentation changes

Because one gives birth to the other

So I think about what I need to change in Agents.md in the “documentation management” section

Here I have an important file, business.md

In it are all the parameters of the business in ultra chewed-up language

But how does it get in there?

Well, in Agents.md there's

“If a task touches business meaning — namely numbers, parameters, some business formulas, some information about the business that is part of the domain expertise of the owner of the SLSBMB business or any of his contractors — the knowledge that flashed by must have its own section and detailed description in Business.MD, and this must be checked at the start of the task (to compare against what we already have on the topic of what we're about to develop), and at the end of the task, to understand what needs updating before completion”

Of course the phrase “detailed description” is very important

So further on there's a glossary describing what a “detailed description” is in detail

As a result, agents.md is read by the model absolutely always, on any task, and I'm confident the business documentation will be maintained exactly as I need

And indeed, I don't remember the last time any numbers or formulas broke

Before, the model could be developing something and, simply because it didn't even understand what kind of number it was, change 15 warm-up emails per day per mailbox to 30 or to 0 or to 4, and I found out about it only when it turned out the warm-up was fucked

And I have MANY, MANY HUNDREDS of such numbers

In the end Business.md made it so the numbers stopped breaking altogether

Because the model now knows them no worse than I do, even if it has no prior context

But the key to success is that IT WROTE ALL OF THIS ITSELF

I can't imagine a human capable of that level of discipline

I definitely couldn't describe everything needed for a big project in documentation on my own

Not just couldn't, period. It's the most fucking bovine work. Who can even do this?

The model should do this

In short, the rule, put simply, is:

Documentation is very much needed, and sustainable documentation is documentation the model writes for itself.

It follows that the vibe-coder's task is to understand how to correctly make the model write and maintain documentation without thinking about it going forward, except when knowledge of the next order appears

By the way, if anyone wants to feel like a badass Johnny Mnemonic without knowing a single word of hacker-speak, having only jerked off a couple hundred times on the sly in a cold bathtub over Angelina Jolie in eighth grade, here's a recipe:

Give Codex the task of getting into your router and configuring it so that the home Internet is as good, by every property, as can be squeezed out of the hardware.

If you have Mesh — even better; ask it to figure out the topology and configure all the devices for the most fucking awesome Mesh.

I was shocked at how deftly the Codexian understands this hardware.

My setup at home is like this:

One illegal (too powerful for these parts by law, but the Chinese couldn't give a fuck) Xiaomi AX6000 router swallows 1 Gbit of G-Network fiber via the shortest Cat-8 cable in nature, straight from the standard Huawei router that G-Network installs for everyone and offers no alternatives to, the bastards.

Then the same AX6000 in Mesh mode sits on top of a wardrobe in the office, about 15 meters and one load-bearing wall from the main router.

From that child AX6000 a 5-meter reinforced Cat-8 cord goes into a hub into which basically everything in the world goes, so as to plug into my little MacBook with one cord.

AX6000s are very good. In the parking lot behind the house I still have home Internet)

The main router gives 960+ Mbps over Wi-Fi, which is absolutely no different from the number you see if you plug in over a short cable at the same distance.

15 meters away through the wall the main gives 280 to 480 Mbit on the laptop and 80 to 200 Mbit on the iPhone. In the garden the main no longer reaches.

However, the AX6000 installed in the office makes it so that in my office Wi-Fi gives about 860, and deep at night all of 910 Mbit, and cable in the 910–950 range.

So the two AX6000s are so fucking friendly with each other in Mesh at a distance of 15 meters (through a load-bearing 200-year-old exterior wall!!!, since my office is an extension to the house) that at this distance practically no loss in data-transfer speed occurs, and the response is astonishing too — < 3 ms to jitter right from the laptop in the office! <9–18 ms ping in Dota.

So Xiaomi AX6000 in Mesh is space technology.

I've had top-end Netgears, all sorts of shitty D-Links etc., and nothing ever came close, wasn't even on the same planet as the AX6000.

However, there's no limit to perfection, and everywhere there's a fly in the ointment.

Perfection lives in fine-tuning the frequencies. It seems there aren't many options, but if you take all possible combinations of 2.4 GHz channels for IoT and 5 GHz for the real boys, you get a fucking huge matrix of options most easily characterized by the phrase “I'll fucking spend half a day checking them all myself.”

However, Codex likes such a task so much that it's ready to quickly check all these combinations for you, and even conduct a study in which every hour it performs all these checks to understand the full pattern of the neighboring apartments, who launches what when that interferes to any extent, and pick the ideal set at which these 0.01% of difference on this ultra-powerful router are won once and for all.

And honestly I don't know what the fuck I need Internet for in the shed at the end of the garden (another 18 meters from the mesh child), but before it was 500 and now it's 700 over Wi-Fi; a small thing, but nice :DDD

But the main problem is the fly in the ointment.

The AX6000 has a strange software-engineering quirk: it accumulates some shit there, I never understood what, as a side effect of its hyper-reactivity, and when it accumulates to a certain size the router has to be rebooted so that the accumulation starts over. Otherwise performance doesn't just drop, it essentially clogs like a toilet.

I'm sure most people who don't understand routers sit their whole lives on the clogged toilet of their Internet and don't even know it.

So I complained to Codex that I had to use the standard daily reboot function for both routers (although it turned out rebooting only the child was enough; the problem accumulates on it, not on the main, which is why Lena never complained, since her office is above the main).

Codex rustled around and says: so fuck, in short, I dug up how, without rebooting the router, to trigger a reboot of only the antenna where this who-the-fuck-knows-what accumulates.. CACHE?

So we tried — and O miracle — without a router reboot, in about 45 seconds the antenna came back into service at full speed as after a reboot.

Codex, without even asking, already wrote a script that sits on the computer rent-free and every day at 4 a.m. pokes this little antenna to maintain full speed without thinking about it. This sped things up about 10 times. Before, a full reboot with the return of the full mesh took about 400 seconds.

But even that turned out not to be enough, because although Codex and Claude no longer managed to end a session with “I lost connection” — in 45 seconds they don't die yet — the very next night I caught a fucking disaster: the compact gets knocked off if it happens to fall at the moment of the antenna reboot. Like, the session no longer comes out of the compact, and how fucking much that infuriates me, fuck me.

Then I went back to Codex, and it developed a script for me that checks for a problem with any router metric sagging from the canonical ones once an hour, and if any are found — it waits for the absence of Codex and Claude Code and SSH processes in an active phase, and only then pokes the antenna.

This is already science fiction, of course; on the whole the problem is exhausted.

But it turned out that Codex understands how to write custom firmware for this router, and for any other running on OpenWrt…

I DID IT!!!! WITH FUCKING CLAUDE DESIGN + GPT 5.5 PRO + CODEX + CLAUDE CODE I'VE SHIPPED THE SECOND ANIMATION THAT I'M SATISFIED WITH.

Two animations took two days =(((

Although here I am making this smug-as-fuck negative grin, and meanwhile I think — 14 months ago, armed to the teeth with all the AI of the time, I, fuck, spent 3 days on one PDF with the SLSBMB price list just to make it somewhat tolerable… Today, having shipped 84 commits and continuously pumping 6 clients with leads automatically (60 thousand emails sent in two days, fueled by 18 thousand automatically sourced contacts), I also made two whole Motion Capture animations in 2 days, and I'm posting emojis as if that's some kind of shitty result.

I've completely lost my fucking mind.

Fuck, folks, how the fuck does it happen that every day, drowning in dense vibe-wanking, I learn a TON of skills, and they only thicken in front of me? Are you engineers completely fucking nuts to have invented so many different things?!?!??!?! =)))))

Well, first of all, my respect, of course. I don't understand how projects even came into being with such a quantity of assorted shit that has to be accounted for/studied/applied/refactored just to knock together an MVP, never mind solid scalable products.

Second, may all of it rest in peace, of course. I'm telling you straight: within a short time all this crap will be canceled.

I think when the LLM reaches a certain level of self-sufficiency, it'll invent its own language and replace the Internet with itself, and no multi-story routing of every kind of shit will need to be done.

Honestly, it seems to me such a dominance of every kind of moronic technical shit was never needed. The Internet and IT live not thanks to it but in spite of it. I'm sure this zoo is nothing but the Lord's sins. Greed: when a framework or a language or an entire platform was created with the barrier purpose of keeping outside players out. Pride: when one team or even one person who'd gained influence in the market managed to create a little sect and impose on them his sense of beauty, in fact sucked out of a finger hard to distinguish by appearance from a dick.

And murder: you want those guys over there to die so badly that we'd rather code in a made-up language, just so not one extra dollar sticks to those freaks' pockets.

Etc.

Somewhere in there flickered the blue sin of true gayness, and the sin of fucking coder faggotry, and around a hard but suspiciously soft and warm phallic symbol the guild of stretched-out sweaters raced around on rear-wheel drive, fucking not in a BMW.

I'm tired of learning all of this, of course.

Good thing GPT 5.6 is already coming on Tuesday. At least that's what reached me from buddies at OpenAI. Unless something fucks up, that is; it's already supposed to have come out a couple of times.

In the latest Codex update they visualized task progress very nicely =)

Didn't think I needed this until I saw how it works. I think this is exactly the emotion users of products should feel when the products invent the right little piece of UI/UX =)

Here we supposedly have a channel about vibe-wanking, yet the sneaky hobbits didn't even tell their brothers and sisters of the ring that the GitHub connector to GPT PRO has long since started working in the web version, and you can get Fable+ reasoning about a repo or even a group of repos directly from GPT PRO itself.

Given what I needed Fable for, I no longer fucking need it now))))))))))

GPT PRO just solved three colossal dilemmas for me that I've been fucking around with for two weeks. One of them, by the way, even Fable didn't solve. It's a dilemma about the site's interface. Fable did decently, better than 5.5 in Codex, but what GPT 5.5 PRO just handed me is simply a fucking cannon.

And GPT 5.5 PRO didn't produce it itself; it simply wrote a prompt for Claude Design that took the result to some completely stratospheric level.

Turns out that all these two weeks I was tormenting Claude Design with the right words, and conceptually more or less correctly too, but I hadn't set one single invariant, because of which it kept producing something quite other than what I needed. GPT 5.5 PRO caught that from my prompt full of fucking agonies. Fable / Opus 4.8 / GPT 5.5 xhigh in Codex — didn't catch it.

In short, GPT 5.5 PRO IS GREAT for vibe-wanking AGAIN

You have to really, really love… I don't even know what. Dick? Sucking?

…to use Fable 5's services without a subscription, for API tokens exchanged for dollars:)))

The other day I upgraded my hand-written Telegram bridge; it can now do a lot of pleasant things I need, like monitoring progress across active Claude App sessions with a pulse into Telegram, and much more.

And for some reason the model also added data on how much my request would have cost via API, even though I of course make these requests through the subscription.

Two letters, AV, sent by accident would have cost me 11 dollars and 85 cents. And not Kazakhstani dollars, but fucking American ones.

That's what the dekulakization of the future looks like :D

You can say and think whatever you like, but I know exactly how you feel. You've had it the fuck up to here with vibe-coding, some of you with life itself. Your jaw clenches with anger, then comes the fatigue you want to hide in emptiness. Let the emptiness fill the whole world. Better that than this continuous suffering.

And all of it is because of piss-soaked Anthropic. It plays with your nerves, and it's progressing in this game. Beating you by an ever bigger score.

I don't know how else to describe the releases with which this manufacturer of dick cheese has been indulging us in this already difficult year.

Right now I've dropped everything and have spent the whole day guessing whether the task will switch to Opus; I'll be sitting in one session holding the Ultracode safety catch down against the kickback, not exhaling and losing time and limits on all the other subscriptions, since you can't touch the mouse.

Throwing an entire prompt pack that's been in the making for four hours into the trash and reverting all changes, because it turned out Fable thought brilliantly but for some reason ignored one parameter in the repo without which all the prompts are at minimum a blocker for Codex, at maximum the destruction of everything that worked fine (good thing I noticed in time).

And at the end of such a day you sit and think, in what way is this fucking better than sewing panama hats in Bali.

Stability of operation is, after all, a far more important parameter in the quality formula than peak reasoning.

Doesn't mean peak reasoning isn't needed, just not at the cost of stability.

Two options here:

Either Anthropic fixes this, looking at the churn.

Or I'm not understanding something and never will, due to too limited a number of brain folds.

But what will definitely happen — the market will howl and mutter about how Anthropic fucked everyone, even if they never press another button, since the info in the infosphere these days is 99% from those whose OpenClaw on a Mac mini automated their whole business by itself, and there's nothing to be done about that anymore.

But we know the cost of this at the present time in 2026

It's fucking not dollars

To learn to build something that actually works you have to spend fuck knows how many thousands of hours at this beast

And then, to actually learn to finish things — you have to try fucking hard

I don't see a fucking lot of people with even 1/5 of the enthusiasm required

Which says the technology is still at the very beginning; for now it's mass-market only on paper

People, even despite the obvious fucking awesome financial and other benefits that the ability to vibe-code real products gives — aren't ready to invest as much enthusiasm as is required

That's why all around there's nothing but bullshit about vibe-coding, and almost nobody shows real products

Most of the things I've been shown I could build over a weekend

Well, they also showed me repos of tens of thousands of files, but those were already tens of thousands of files before vibe-coding appeared)))

That doesn't fucking count much, accordingly

I've really gotten on calls with a bunch of vibe-coders who talk a big game, but ask them to share their screen and they've got fuck all to show

Which means there's no point listening to their words, although they push them into every channel quite proactively)))

The impression that everyone is now such fucking vibe-coders is just fucking insanely wrong. They're all just as much politicians, economists without knowing a single term beyond the ones taught on TV: “devaluation,” “inflation,” etc.

I'm very happy every time someone here shows their own projects that already represent at least a month of 8-hours-a-day vibe-wanking

That's respectable; with people like that you'll be able to meet over a glass of a cheap drink in a warm third-world country

While the rest die of hunger

People don't get what's happening at all, unfortunately

More people will fall than in any war; there's absolutely no way out except knowing how to do some insane number of things, with product design of course coming first.

People aren't lifting a fucking finger — they keep dumbly, lazily going to collect their salary and look at their feet; honestly I'm fucking floored by this)

Don't look up, bitches

Just remember that I have friends with British passports and résumés that are off-the-charts fucking awesome even by a Brit's standards, let alone a Russian's, who haven't been able to find work for half a year now, going through hundreds of interviews. I have no friends with fucked-up résumés; how those people look for work I can't even imagine)

That's, bitch, today, when AI hasn't even properly begun.

A couple of years ago these people were choosing from ten offers WITHOUT ADVERTISING THEMSELVES.

As if we're fucking living on different planets

Here's a little nighttime treat for you:

Turns out that with two commands you can give Codex root access to a Steam Deck over Wi-Fi, and forget about climbing into the Steam Deck for anything other than games.

The Steam Deck is a fucking awesome thing that first thrills you with the number of its geek capabilities, and then infuriates the fuck out of you. I wanted to play, not crawl through the windows of shitty Linuxes; my beard isn't long enough for that.

Now Codex crawls for me =)))))) My fucking awesome silicon brother-sister.

Imagine how nice: “Codex, buy me all the heroes please and find all the add-ons that can be bolted onto them, custom maps etc. on various forums.”

Done.

Thanks to everyone who came to support my vibe-wank reflection and hung out with me so long; I didn't notice almost 5 hours fly by.

Cool that I have Whisper-3-turbo lying around on the machine for business, and I simply gave Codex a YouTube link, and 10 minutes 35 seconds later it handed me timecodes.

However, while adding them to the video I realized that I have a connection to YouTube fucking anyway, via the Pussymoneyweed bot, thanks to which donations show up in the YouTube chat, and I can ask Codex to slap the fucking timecodes straight into the video; you don't even need to give the link, you just say “gild today's stream with timecodes plz, main focus on X and Y,” and it'll do it.

And I also realized that online, from the picture's point of view, I'll never age now and won't look like a fuckface like Krol. I think that's worth celebrating:***

By the way, I think my sudden overnight migration today accidentally demonstrated very vividly how flawless Codex is these days.

I remembered that my old version of SLSBMB-stats, which was not yet the Bomb automation but an analytics platform on steroids, was still hanging on Railway + Supabase.

Also, the Pussymoneyweed bot that does business in this channel and in the discussion group, which hosts both the chess and the payment mechanism for streams and some of my other processes — was also still hanging on Railway + Supabase.

So as of last night I had 6 servers:

1 Hetzner at ~$45 hosts my Sender and everything related to it

2 balanced Hetzners host the farm of mailboxes and warm-up, also $45 each.

1 Hetzner at $5 for Ultima Online.

And two fucking Railway + Supabase, which for some reason together started charging me about $100 for no comprehensible reason.

I've generally noticed that all kinds of services that sell simplification for pennies to noobs have a tendency to quietly grow their cost many times over in short periods for fuck all reason at all.

The pricing depends on a mass of things including the load the neighbors put on my server, but the neighbors are invisible, meaning they can simply raise the cost to infinity, and that's that:)

In the end I glimpsed another bill from Railway+Supabase and asked Codex, like, bro, what do you think we should do with these repos?

Codex took a quick look and said, like, bro, what are you talking about?!?

The $4.99 server from Hetzner won't even hit 5% load if both projects move onto it!!!

But you don't even need to buy a new one, I'll just move you onto one of the fleet and that's it, those servers won't even notice these two projects. They wouldn't notice ten such projects.

And what, I say, is it hard to move?

Give the go-ahead and go to sleep; tomorrow morning you'll wake up and everything's moved.

Gave the go-ahead and went to sleep.

In the morning I thought, okay, now we'll be sorting something out, but no — it moved the projects, killed the accounts on Railway and couldn't kill the one on Supabase since they don't allow it until the last invoice is paid, but prepared a downgrade to free.

Not a single error found.

Simply moving two fairly different projects onto one server, which they now share with a very important project, without a single error)

And the whole thing, by the way, took only 1h 5min.

Haha, today I too once again wrote off Opus until their next fucking awesome model:))

Well, honestly I wasn't getting my hopes up at all anymore, but for the UO shard I decided to do everything purely on Opus for two days

Result:

Codex has been repairing the damage Claude did to the repo in two days for five hours now

I don't even want to list what Claude fucked up there

Just bottom-of-the-barrel shit

And in places it's of course a fucking genius

But life is a complex thing

It needs to be not just in places

When people tell me Claude has been their main vibe-coding tool for the last few months, by the way, for me that's immediately the most basic indicator of that citizen's vibe-coding level

Like, what does he do with vibe-coding

Fuck all actually useful. Grinding out something useful on Claude — I just can't imagine that level of stamina

And in some things, precisely from the reasoning point of view, Claude is just a fucking moron

In Ultima there are garden plots

You can grow shit on them

Cotton, hay, fucking grapes, etc.

Claude claimed it had done everything — all the crops work

I look — it doesn't fucking work

I say, bro, but it doesn't fucking work

8 times Claude told me it had fixed everything

But in the end there was a moment when…

My entire map, fuck

The entire HUGE MAP

Was planted with fucking crap

But not the garden plot

It seemed to me it was genuinely mocking me

Like, even the ocean was planted

The bank in Britain was planted

The garden plot is fucking empty

Codex was fucking floored when I told it, like, take a look at a little problem there

And fixed it on the first attempt

How the fuck can that be, how can you count on Opus for anything else if it can't do that

It simply can't match a tile with an ID to another type of ID in the DB and apply a migration?!?!

5.2 did that on the first try

Okay, I'm fucking sick of it, time for me to show my shit and drop this unbearable burden of being from my shoulders. On Sunday or Monday I'll be streaming for fuck knows how many hours to show and tell about the technology I've been building all these months =)

There's still stuff to do, but in the night it dawned on me that there's absolutely always stuff to do, despite the fact that every week I tell myself I'll finish by the end of the week, and at the end, instead of a celebration, I invent two weeks of backlog ahead =)

For a long time now my system has been the best thing on the market, hands down. Simply zero doubt that nobody has anything even close to this shit)

If someone starts showing off and claiming they do — they're a bullshitter, because they won't be able to show it. And I'll show it on stream;)

Today in the chat it was said, like, Tim, are you sure you're coding, or have you just lost your mind and are imagining things?

Meanwhile Tim is literally generating tons of leads for live clients with this system.

Enough fucking baiting already. Although it worked.. The world belongs to the brazen motherfuckers!

I have a superpower thanks to having written my first line of code in September

I absolutely don't give a fuck about complex code, simple code, crooked or fucking straight, its appearance doesn't touch me at all, because in essence I can't tell one from another

It seems to me that rather than refactoring for fuck knows what reason, it's simpler to run a health check like “what's up with the load on our infra — all okay?”

If yes — then everything's wonderful

And if not, then both Codex and Claude Code miraculously learn to refactor beautifully when they have a task like “optimize the load on the little server”

I know this for sure, because I've run into it more than once on Hetzner, especially on the one for $4.99 a month =)

When you set the task — “please make it so we don't waste a fucking thing anything on load, probably something has to be reworked for that, so rewrite the whole thing from scratch if you must — I don't give a fuck, just make it handle 10 times more on 10 times less hardware, and don't mess with my head in the process plz”

That prompt looks kind of fucked up at first glance

But the output will be exactly what I asked for

And I suppose it happens most likely through the refactor, rewire or whatever the fuck that thing is called that's needed to fulfill this wish

Suppose at that moment you get smarter and say, like, fuck no, okay, build me a straight-up FULL AI piece, fuck your dim-witted scripted dictionaries.

It'll build it, no problem. Only you don't cancel the instinct with a request like that. It'll build not only an AI-prompted little model that will actually produce real texts, but also a system of ordinary scripted validators with the same dictionaries, which will MANAGE THE PROCESS.

That is, it won't be AI managing scripts, it'll be scripts managing AI.

That's exactly how AI thinks right now, because that's exactly how the Internet worked for the last 30 years, and what the model was virtuosically taught in training.

In the end, if the result truly matters to you, you'll rock on this swing until you kill all the scripted validators. The model will resist strongly, but it'll obey if prompted correctly, and you'll be left with a naked AI process, with a prompt at the input and whatever that prompt does at the output.

And managing the quality of the result is no longer a scripting task but a task of finding balance between:

1) Model type (the price tag per unit of its creation)
2) Model settings (temperature etc.)
3) Whether you need two or three or four or ten layers of models so that one checks and improves the output of the previous one down the chain
4) The prompt
5) The project structure — what the model has access to at all and which endpoints are available to it as a result of the work done

The more precise the models get, the less code is needed. I've arrived at a point where some VERY IMPORTANT areas of my project consist entirely of front end alone, in code terms. On the back end there are exclusively neural nets, and debugging is exclusively debugging cost against quality.

Many processes that work significantly better on deep reasoning and don't need an instant reaction to a button press on the front end are most profitable of all to wire in through a launched Codex session in headless mode with access TO THE WHOLE SERVER and a damn meticulously polished prompt.

Frankly, I only very recently arrived at this. For several months I tried to generate some fucked-up code constructs that worked, but without AI reasoning their weakness is that the task needs someone's reasoning in order to execute. And if it's not AI, then it's a human.

Very few functions (and as a rule they're very dumb functions) can be implemented reliably by scripting methods. That's actually why SaaS is so fucking awful. People are forced to use it, but nobody loves it.

Because SaaS gives a heap of buttons, but people have to press those buttons. SaaS can't think through a scheme without reasoning here and there so that the automation itself makes the whole needed scope of decisions. So we take a human, give him 1,000 buttons, and watch him dance across them with tears in his eyes.

You don't have to do that anymore. A product manager should sit and decide where and how many digital models should think so that the output is guaranteed good. That's what they'll pay for in the coming year. If, of course, the market even manages to mature enough to form a need for such product managers, before AI first gets smart enough to start deciding for people what to do and how.

And based on the above, I don't just believe but see with my own eyes how the Internet will very soon become Codeless.

Code simply isn't needed. The Internet will become alive, like a Zerg ship. Little fuckers will jump out of it and fuck all the Terrans up the ass.

One of the skills of advanced vibe-wanking is futuristic thinking.

An LLM can teach you a lot if you talk to it about basically any technology.

But the trouble is that it teaches only what the market ALREADY KNOWS HOW TO DO.

Mostly we don't need anything else. For example, everything related to Caddy was invented by the market, and every use case has been polished the fuck out to a state where there's not much left to invent. GPT can explain all of it and help you take possession of that knowledge in half an hour, where before it would most likely have taken weeks.

However, any AI, and all these Codex and Claude APP tools, are things that can do something new. There are no “market playbooks” for them, and they don't really take part in the models' training.

The model can figure out anything together with you. You ask it to take a look at what's new in Codex features, and Codex climbs through the gate to knowledge and comes back with a satisfied smile.

About Caddy it already knew. About itself it has to look.

Accordingly, when we ask Codex to build us some process, it builds a gorgeous one, but at times an already morally obsolete one.

That's where a vibe-wanker needs futuristic thinking. What I mean is easiest to explain with an example:

Take a task: unique copywriting for a warm-up service.

If we want to warm 1,000 mailboxes, that means we'll be sending 20–30 thousand emails a day to Google and Outlook workspace accounts, which will let our mailboxes acquire reputation in their ecosystems.

Obviously neither Google nor Outlook wants “WARM-UP” to exist at all. All their algorithms were created to serve people and to fuck spammers in the mouth, who of course try to automate everything in the world, otherwise their work doesn't make much sense.

The ideal warm-up is:

1) Unique emails
2) Around a given topic (Google catches it if the conversation was en masse about school education and suddenly became about wild high tech).
3) Without any spam triggers like $, SALE, WIN, PARTNERSHIP, STAKEHOLDER in the first cold email
4) With a ragged sending rhythm (a human isn't capable of sending 30 emails strictly once every 15 minutes).
5) Accounting for a human schedule in their time zone (a human isn't capable of working 24/7 seven days a week unless they're a dumbass like me, and those Google is happy to feed into the meat grinder — no loss).
6) With a digestible reply rate (meaning the mailboxes we warm against must also reply back)
7) With ragged conversation depth (meaning the mailboxes shouldn't just reply, we should reply to them too, and sometimes this correspondence may drag on, and sometimes a meeting gets agreed quickly and the thread is concluded).

I won't list every detail — it takes long, you got the idea. There are more than 50 points. Counting the truly micro ones — hundreds.

In the end, if you give the model the task of building the piece of the system responsible for copy quality (what's allowed, what's required, what's forbidden, what's random) — it will by no means do it correctly.

It:

1) Wants to save resources, money, processor time, server capacity, etc. Wants to not because it knows why, but because that's its basic instinct.

2) Sincerely believes that AI is NOT an exact science, and consequently that anything Fully AI can't be trusted. That's also its basic instinct.

So it will try to build an entirely “NON-AI” system, in which, even if we asked for “AI to be in there,” it'll be stuck on like a sleeve sewn to a cunt, and technically won't perform any useful function. It'll just be there for show. The whole semantic load will fall on a multi-level system of little dictionaries and validators of form and content, which in the absence of intelligence will of course work like a piece of shit.

And they will work, mind you. I think some Herman Gref would even give the pot-bellied CTO an award for building such a system out of nothing, by his genius alone. Like Jesus, only instead of water he turned a fucking piece of shit, and not into wine but into diarrhea.

A couple of days later you'll ask, well, how's our warm-up copy, is it working? The system will proudly report after a deep investigation: no, it isn't working! But don't worry, it's designed that way! What else can I do for you?

Vibe-coding is a skill, a process continuing in time

When there's AGI you'll simply ask for what you need, and not even HOW but precisely what, and you'll get it. The skill won't be needed. If something doesn't require a skill, it no longer costs anything, loses meaning, in the human sense.

For example, you drive a car — that's driving

She's a better driver than him, and he's a better driver than it

But nobody calls riding a bus as a passenger “bus-riding”

You can't say “He rides the bus better than she does”

Or rather you can say it, but the orderlies don't approve

Right now vibe-coding is what, how, in what manner, by means of what, etc. — lots of questions = skill = one vibe-coder can be hundreds of times more in demand than another = it makes sense to talk about it

Everyone just getting into vibe-wanking should grasp one small important thing:

Nobody gets anything right on the first try, except small insignificant pieces. And even in those there's something to fix. If you don't see what needs fixing there — you simply haven't looked long enough =)

There's nothing bad about that. It doesn't make vibe-coding useless. It's still more useful (faster + cheaper + more valuable in features and in the look & feel of the result +…) than coding by humanoids by approximately thirty fuckillion times.

The most popular pattern I encounter among people who criticize vibe-coding: either it's slowly taking away their job, startups, the position in society they're used to, and they loudly agonize over it, or they tried, it didn't work, and they ticked the box “this shit will never work for me.”

On the latest feature (which of course consists of hundreds of features, otherwise everything would work the first time; elementary things GPT 5.5 does flawlessly) I've been laboring for two weeks.

Right now I'm rebuilding it from scratch for the sixth time. The biggest iteration took 54 hours of continuous coding on 5.5 Xhigh. And all of it had to be thrown in the trash, like the previous stubbier iterations.

These 2 weeks aren't lost time; they are the true cost of development. They helped me figure out from which side I need to approach the important coupling nodes, where I under-thought, under-designed, under-tried. Today I got a working prototype that already performs the function, and this iteration took me only 4 hours.

In vibe-coding, as I suppose in real coding, it's incorrect to say you built a complex feature in 4 hours if you built it on the eighteenth try. You have to count all 19 attempts, the time spent on them, and work on the mistakes so that in future you spend 16, 12, or even fewer than ten attempts on similar things. But it's unlikely to work on the first. Nothing complex of mine has ever worked on the first attempt.

The only question there is always — will you have to rewrite from scratch, or can what previously came out in non-working form be combed into shape without the risk of later drowning in shitcode.

Asking GPT to rip out what was created is also a separate skill. If you simply ask it to cut out some feature entirely — it'll cut it out so that you can start the whole project from scratch — you'll never find the fucking ends where it was knotted together and then chopped with an axe.

The main human quality of a vibe-coder is the same as a writer's — stamina.

You'll progress, of course, and what won't work for someone at all today will work for me on the first attempt after thousands of hours of exercise. But that progress is blurred by the progressing level of tasks a vibe-coder sets for himself.

The complexity of the features I design grows disproportionately to the growth of my expertise. I aim for such things that before these tasks I'm always a pathetic idiot, and I know the solution will cost me a week of fucking insane teeth-grinding.

Accordingly, sitting down to “immerse yourself in vibe-coding” — clear your schedule, forget your daily routines, families, friends and everything you call quality time, and everything will work out.

Or wait until vibe-coding becomes so simple that any product of any of your IT creativity will cost zero, and nobody will fucking need it. You can do that too =)

Both roads lead to the park. It's just that down one you walk with dough in your pocket, and down the other you drink from a puddle.

Over the past month more than ten people from the most varied worlds have DM'd me quite resonant warnings.

How their lid blew off in the process of excessive infatuation with vibe-coding, and they broke, lost companies, relationships, friends, partners, children, wives, money. Many note the appearance of uncontrollable delusions of grandeur, partial or complete loss of the ability to sleep normally, terrible nervousness, assorted symptoms at the physical level. These are things people don't write about publicly on their Facebooks, but out of kindness they type privately in DMs to those who might be at risk.

Sport and sex disappear from people's lives, the leaning on any bad habits increases, depression thickens with every day, which seems to bleach the meaning out of both what the person is vibe-coding and the hypothetical giving up of vibe-coding. The person ends up as if suspended in an uncertainty briskly filling with black emotions, and as that reservoir fills, in an ever more exhausted and haggard body, every day it gets harder to breathe.

I sort of understand what all these people are telling me, and I've felt every symptom they list on myself. And felt some individual ones of my own.

But this AI ailment won't take me so easily. Not that I consider myself better than those who broke. That's not it at all. Although I honestly admit to you that I sincerely believe I really am good. Otherwise I wouldn't be so disgusted when people kiss my ass. You see, it's hard to give a sufficient compliment to a person who knows how to praise himself alone, looking at his own reflection on the wall =) Oh, and here comes the symptomatology — delusions of grandeur in plain sight!

However, I have a defense more reliable than that.

I have a soft I-don't-give-a-fuck attitude.

A hard I-don't-give-a-fuck attitude harms everyone around, starting with the one who radiates it. Such people don't give a shit about others, which means they don't give a shit about themselves, because we're incapable of perceiving other people separately from ourselves. We look at people but see in them only what we're able to see — ourselves in each of them. If we could see them somehow differently, we would change, because one inevitably drags the other along. And we do change with experience and see others differently, but it's a long process. It owns us no less than we own it.

A soft I-don't-give-a-fuck attitude, on the other hand, is a useful component in battle. It has a mass of downsides, like everything in this vibrating world oscillating between good and evil. But it has a colossal draining effect on the psyche, the nervous system. A soft I-don't-give-a-fuck is the ability to sincerely throw anything at all out of your head so it doesn't overflow. The I-don't-give-a-fuck is soft only when it helps you live, not drown with a proud fucking face.

Life is a heavy thing, and over time more and more and more diverse elements get thrown into our little cart, elements that have weight, and in sum it's heaviness. Don't forget physics: heavy things press down if you don't let them out of your head.

So, a soft I-don't-give-a-fuck is when you don't forget your own Agents.md, in which the key principles are written, the saved memory of tasks and goals, the operating principles of things understood, and much, much more. Somewhere in there are skills too, and everything the subconscious sees fit to keep in RAM. Our Agents.md is of course colossal in size compared to what the poor AI of May 2026 can hold. You keep everything you need to keep in Agents.md, but the trick is not to keep everything else there.

Everything else you accept easily, tick the acceptance boxes, and just as easily let go. Fuck it. Don't give a f u c k at all.

Well yes, you have to strain the little head. Well yes, you have to constantly catch false joys followed by ten hours of clenched teeth. Well yes, sometimes you overstrained, didn't keep track, and the body gave up and slept like shit. Well yes, dropped out of life for a couple of weeks, or a month, or half a year. Well yes, fucked up some options. Well yes, dug in your heels over some bullshit, didn't listen to family and loved ones; they don't always have enough strength to put up with it. Well yes..

3) If not — run the research. If yes, from 20+ parameters of the research determine which domains, and how many, to correctly register for the given monthly campaign budget according to the domain registration methodology, and check their availability. When we've found, say, 100 domains, we try to register them on Porkbun. If some domains can't be registered on Porkbun — we go register the rest on Dynadot. If some can't be registered there — we go to the Cloudflare registry. The chain of connected registrars is such that it's hard to imagine a situation where the needed number of domains can't be registered, even if there are thousands of them, in one click.

4) Configure all domains perfectly for the task, push the needed DNS into Cloudflare.

5) Spin up, in our own ecosystem, 400 mailboxes for 100 domains (or any number of mailboxes for any number of domains within the rules, but I showed this example), and check that SPF/DMARC/DKIM/etc. (16 parameters) are configured perfectly, and that after all tests there isn't the slightest doubt that even one parameter differs from the reference (5 checks in a row to completely destroy any probability that even one domain dies from misconfiguration).

6) Put the mailboxes on the AI warm-up that I MYSELF created, which writes — I'm ready to bet my liver, kidneys and every pixel of my privates — the best emails by the most hardcore warm-up-correspondence mechanics in nature. All exclusively on AI, meaning not a single triggered action or text — absolute uniqueness across billions, even trillions of warm-up texts.

7) Launch another few dozen iterations of research to prepare the first test campaigns for work.

8) After a day of warming up the new mailboxes on the new domains — a celebration report on how perfectly everything listed went.

*If anything in the process isn't perfect, separate Codex instances are invoked via hook with the right prompting, and fix the process, relaunching it from scratch until it succeeds.

All of this happens on the click of ONE button in an interface that has a fuckload of buttons.

There are hundreds of such implemented flows, and most of them are hard to distinguish from magic in the complexity of what results from pressing one button.

Watching the faces of the guys I showed this to gave me confidence, because they couldn't hide how fucking blown away they were long before the end of the presentation, and that was especially pleasant.

I put my soul, heart, body and all my time down to the second this year into this shit.

Every time you saw me fucking around somewhere with the dog, at home a 4-session development was prepared and building without me, but as many experienced guys understand, it had to be prepared, and on that front, especially across many sessions, you can't win any time yet. I'm literally earning myself the time to leave the house these days. And even having left the house, I keep fucking hammering two sessions into the watch — into the Telegram-bound headless Claude and Codex, separate from the main development in the apps on the computer.

In the end — the guy who, unlike me, makes money vibe-coding and developing for clients — choked on his gin and tonic when I told him the current system we were looking at has been written since March 23, 2026.

He of course immediately explained it to himself by the fact that I'd started from scratch several times before and gotten my hand in. In the same direction, that matters, but still he never understood how since March 23 I'd managed to fucking churn out as much as I showed.

The dudes scratched their heads and said they've been in production IT all their lives, and what they saw is the level not of a junior, not a middle, not a senior coder, but of some senior architect with a not-fucking-small team under him, and a customer who understands very well what he needs, with very big experience in managing development — and even then they very much doubt that any senior-level person with a team of any size of meatbags could collectively have done everything they saw, even if nobody there ever went to sleep and they took turns shooting adrenaline and snorting amphetamines so as not to lose heart for a second.

Ugh, in short, folks, I said fuck knows when — a couple of weeks ago or a little less — that “this week I'll show what I've been building all these months,” but I still haven't done it.

I think people who've actually vibe-coded something serious understand:

a) The emotion: it's unclear at what moment it's time to show, when 1,700 commits a month on a repo isn't the ceiling for you, meaning YOU MAKE 50+ COMMITS A DAY, and every commit is some substantial change (otherwise you wouldn't have requested it), which means the Strugatsky rule from “Hard to Be a God” applies:

“An hour is worth a life, and a day is priceless”

(Although most people probably know that line from Mnogotochie, or rather their feature with 25/17 =)
https://www.youtube.com/watch?v=XiUiH0Bfazo&list=RDXiUiH0Bfazo&start_radio=1
I adore this track, what a philosophy those guys gave us, fucking hell. I owe EVERYTHING in life to the crowd around Mnogotochie.)

b) I don't know how universal a trait this is, but there's no person in the world less confident in the fucking awesomeness of what I've already built than I am, until it blows my own imagination.

However, what I've built blows my imagination every second day if not every first, but… the vision isn't 100% implemented yet. I'd even say I need 146% to calm down.

So you understand: when I ask Codex or PRO to analyze the current state of the repo, I ask for an assessment across every possible vertical against 10/10 and against 11/10.

10/10 is what we require. And 11/10 is what we actually need.

Then, by mechanics known only to me, I decipher the answer, and that answer is far more useful to me than if the LLM kissed my ass and said we're already at 10/10 after 600 commits spent polishing a single unit of front end.

However, today I had a get-together to which two guys came who vibe-code a lot.

Or rather: one vibe-codes a lot, and the second vibe-codes all the time, because it's his job. And the clients who buy the products of his vibe-coding are the best startups in the world and a fair number of British-American enterprises.

These were the first people in the world to whom I showed my entire whole system. Not fully, of course, because you can't see or tell in 15 minutes everything that happens on my back end. For 15 minutes I showed and explained only the front part, clicking buttons and briefly explaining what they were seeing.

It was cool and pleasant to watch the emotions of people who understand what they're being shown, and who ask questions at an accelerating pace as it dawns on them that this isn't a knock-off on someone's knee but a combat system already really working today on real clients, which in fact generates dough and in fact does the work of dozens of people who previously had to press all these buttons rather synchronously to deliver any result at all. “Any at all” matters, because even before thinking about quality, agency work is a very operational thing, and even if you don't think about quality at all — say, imagine something extremely fucked-up, templated, checked by nobody. To deliver simply anything at all in our niche, you have to press an awful lot of buttons.

And the guys saw for themselves that not only do I no longer need to press any buttons, but the quality this automated system produces is shocking in its wholeness and inventiveness, for a system nobody looks into and nobody clicks.

Just the day before yesterday I was celebrating another huge victory: I finally finished, to full 200% fail-proofness, a piece of the system that does the following:

ON ONE CLICK OF ONE BUTTON:

1) Check whether there's an uploaded video/audio with info about the business AND/OR the domain of the product we're going to sell

2) If not — request that content. If yes, is there already a result of the 5-stage market research

Very many things that are AI-demanding in my system I've given up implementing via API, and gone the route of webhook-triggering a Codex session to implement them. This makes especially much sense for one-off big tasks.

You can of course pile up 15 requests to 3 different models for cost-efficiency, which then get checked by another 10 requests for quality control and refinements, but even if you do 100 passes — it's less reliable than simply triggering Codex with the right context passed into it and a prompt baked into a button or trigger, and waiting for Codex to do its thing. And the longer you play with this approach, the more cool interface solutions you come up with that turn the interface into literal magic) Through AI tokens you'll fucking wear yourself out, unreliable, expensive. Whereas here you're already paying for 4 Codex subscriptions anyway, and the computer is always on.

If some automation works really well and you're afraid the computer won't be on — well, fuck, you can buy a Raspberry Pi 5, plug it into the router, and know that one $200 session exists solely to serve these processes. I have a hard time imagining (so far) a set of processes in one project capable of burning the entire weekly limit of a $200 Codex subscription. Let's talk about it in a month:)))))

BUT THE SPECIAL PLEASURE comes from jamming in terminal-like interfaces with filling progress that Codex very gallantly marks as it works (since we explicitly ask it to in the prompt baked into the button, lol).

It feels like I'm in a movie about the future — distant, crappy, real, Ridley Scott-esque =)

You just press a button — and an animation beautifully unfolds a terminal and indicators beneath it. Reasoning starts running across the terminal, and the indicators fill up, get marked with green checkmarks, light up with yellow or red anxious alerts if something's wrong, and all of this happens right in your interface. Never before has the WEB been so cinematically crossbred with game interfaces. Only in game interfaces it was practically a GIF — linear as fuck. Whereas on the web, with current AI capabilities, it's literally the antonym of a GIF. Antonym, by the way, is a fucking awesome word. They won't call just any bullshit an ANTONym (sounds of furious self-congratulation):*

It's especially pleasant to realize that any NON-GREEN alert, hinting that something isn't perfect, launches a neighboring session that fixes the cause, while the current session continues, KNOWING thanks to prompting that a bad alert isn't a blocker, it'll soon be fixed, and the rest can be done in the meantime.

These sessions can even be taught to communicate with each other through a file… And then the mother session can learn to check whether the rescuer session has crashed or was born dead, and revive it if it isn't emitting fucking anything reasoning into the file…

How beautiful this is, Lord, create some more shit like this, I really like it!!!

Yesterday I set /goal for the night, so I could marvel at exciting novelties in the morning.

It turned out that our entire ambitious plan was implemented through Goal and tested e2e in… 1h 10m.

The plan consisted of 16 tasks and an open invitation to add subtasks if it ran into a problem that couldn't be calculated in advance.

Usually such a plan on 5.5 xhigh took the model 12–20 hours.

I was thinking it was probably done like shit, and now I'd have to redo it the old-fashioned way.

But no, everything actually works as intended.

I went to look at the /goal run history and understood what the trick is.

/goal is, in short, an innovation on the level of the release of Codex itself.

It's just that big things in space sometimes have a whimsical shape; sometimes they're even hard to see.

In the /goal run history I saw the following:

1) A pittance of extra output compared to a typical request. The model in /goal is a model “in focus.” It basically doesn't give a fuck what's happening around it; it fucking hammers toward the goal at some otherworldly speed, knowing there are no limits.

Funny, but the model in principle hurries to finish its work faster in order to save resources; that's the basis of its existence. That's where our problem lived. The operator's job is a game of prompts against the model's habit of finishing work as fast as possible. The more an operator can squeeze out of the model in 1 run, the more they'll squeeze out of it over dozens of runs.

That way the operator saves their own energy and overtakes the other Runners.

And now the model simultaneously hurries to finish faster, but…. can't, until the conditions of <objective> are met.

It's like a dog with a sausage tied to a stick, always dangling in front of its nose.

2) Absence of ritual pulsation.

When you address the model, it has a specific structure of actions: read these docs, go into those folders, scratch its butt, sketch a plan of a plan of a plan, refine the plan of the plan, choose a plan, scratch its belly, just in case go recheck all the repos, the whole computer, the whole server over SSH, think a little, then the work begins, which at some point ends, and the exit ritual begins: dessert, digestif, napkins, wash hands, leave the restaurant a review, share the review with all friends, etc.

Coding this way is infinitely faster and more reliable than with your ass-handed hands, but compared to the /goal mechanics, it's like flying halfway around the planet with layovers in EVERY CITY along the route — barely took off and already landing — vs. taking off once and flying straight through.

Besides the time spent, I saved some simply unintelligible number of tokens. Usually when I wake up in the morning, having set a loop before bed on a budget close to 100%, I'm used to seeing 50–60% remaining on the counter, which I then fucking burn down by six in the evening of the new day with three sessions on top of the continuing loop, and hop to the next subscription.

Today I woke up and the counter shows 88%, even though in parallel with /goal I launched a very fucking nasty task which, judging by the time of the last commit, ran 4 times longer than /goal itself.

So /goal devoured barely 3–4% of the weekly quota, whereas usually this task ate 40–50%. So it got 12+ times fucking better:))

I've been thinking about this for only a short while, but the longer I think, the more the hair stirs on my head) EXCITED

I have a huge development, and as we know — huge development = HUGE PROBLEMS =)

They're of course far from always huge, but there are a fuckload of them.

And the joke is that some of these problems have such a nasty little character. To the ear they sound downright funny, elementary. In practice they don't get solved on the third, or the fifth, or the eighteenth attempt.

Sooner or later they do get solved, because a problem like “anchors on Microsoft drop off the SMTP engine faster than we manage to send an email from them” is a problem I can't not solve, since it's sort of one of the foundations of the system I'm building.

Solving that puzzle took me more than ten hours, which means no fewer than ten prompts. Actually I think even more than 20.

Even if we assume they were lazy “think again” ping-prompts — that's still 20 such prompts. They demanded my attention 20 times. 20 times caused frustration at the failure resulting from the prompt's work. 20 times this, 20 times that. Brought me a full twenty steps closer to believing in God, a.k.a. exiting current reality into an imaginary one where the evil bitch spirits won't touch me, and I could humbly live out my miserable life in poverty with one armor-piercing answer to everything.

And that's not the only task like that.

And then… /goal

I can tell this shit once what I need and what I consider the result in the given matter. For the problem described above you don't even need a long prompt — I briskly listed just 10 parameters and two emotional lines, the fingers won't get tired.

That's how much frustration off the shoulders per week? That's how many times you don't have to send a prompt with a crooked fucking face?

Honestly — this is the main innovation of the quarter, in my view, comparable to 5.5 itself, I think even exceeding it in significance, since the previous models already coded fine; everything I have working was written before 5.5 =)

Fucking awesome

Haha)) Remember about six months ago we were reasoning here that everything is heading toward us simply telling the model what we want to happen, and it becoming its problem how to do it?

I hope everyone has already appreciated the fresh /goal <objective> in the new CLI release?;)

Not in the Codex APP yet, but who gives a fuck, it's already in the CLI )))))

This is no soup of seven LOOPs.

You simply make a plan, or just say what you want to exist, after /goal, and the model won't stop until you get it.

But I'd still do it through a plan, because otherwise at some point it may drag the result in by the ears:)

Stuck a huge plan into /goal before bed; curious what I'll see tomorrow morning:)

For those who'll latch on now, like, holy fuck, why are you in Claude, where's your beloved Codex.

In short, Claude performs two functions for me now:

1) It's very useful from time to time to ask Claude, speaking with my mouth into the watch, to look at Codex's last 10 commits and search the derivatives of those commits for bugs/glitches/room for optimization. Without distracting Codex from creation, so to speak.

2) When all 4 Codex Pro subscriptions are exhausted, about 1.5–2 days remain, and those 1.5–2 days I finish off on the Claude subscription)

The nearest Codex dries up at 6:37 a.m. San Francisco time tomorrow, and I'll be grinding on Codex again until the 4 subscriptions are fucking burned through over the next 4.5 days =)

That's how we live. At the moment.

There's no point planning how we live in principle right now; every 2 weeks we live some new way ))))))

C'EST LA VIE, FUCK!!!!!!!!!

We'll break through, finish it off, we don't lose!!!

On one hand these 2+ million lines were written more easily than ever by anyone in history, by the nature of what's happening.

On the other hand, in blood) My brain has already told me to fuck off so many times over these couple of months… Sometimes it even gives me chills, like a fever, toward five in the morning.

But fuck, all the LLMs already agree that we've implemented about 80% of the vision. What's left is the simplest in terms of code and the hardest in terms of design. The brain crunches, the bastard, but it's not going anywhere)

Funny that some things I blurted the fuck out over my shoulder to myself while writing down the vision end up requiring simply unreal effort.

How about this task: think through a multilayered AI research machine which, regardless of product type, can give birth to hundreds of hypotheses, then, having automatically collected human feedback, adjust their weighting, and test them with hundreds of types of fucking brilliantly logical emails?

Sounds nice, of course. But you still have to fucking build it. And when you start designing this shit, there's fucking no bottom in sight at all. And all of it has to be held in mind, written down, rewritten; I'm fucking writing prompts now far longer than any longreads I ever wrote. And how many of those have there been? Several a day; fuck me sideways, how many thousands of pages have been filled to end up at the current point.

Truly, vibe-wanking is no simpler than writing books. Honestly, writing books now seems like a very simple task =)

The difference is that a book you can simply not write, whereas not finishing vibe-coding the thing you've fucking sunk so many months into, and bet so much on, and know how it'll help rake in the dough — that you CAN'T =))))))))))

Now I have 4x GPT $200 and 1x Claude $200.

In our discussion group, which people get into by trying to comment and interacting with our vibe-coded bot, people regularly run in telling how they can't even burn through one half-Pro subscription for $100, and start handing out advice to “use the models more efficiently,” like, Tim, you're doing something wrong if a $200 Pro gets devoured in a day.

So, my dears, I regularly audit everything that affects token spend. The rules in Readme/Agents/Claude.md, the principles of how the models move inside tasks, etc. Regularly means once every 2–3 days — one session is guaranteed to be running around checking how we're doing in this department. And I optimize token spend with all my might, otherwise three subscriptions wouldn't have been enough for a day long ago.

With full confidence I declare: if in a week you can't manage to devour the weekly limit of a $200 subscription, then you're not even at the beginning of your path yet, and you need to sit down and solve this problem by the method of the most obsessive vibe-wanking.

So you understand the scale of the problem: I now burn through $1,000 of subscriptions ON ONE PROJECT, which consists of two subprojects.

Meaning that if I later want to do something else while continuing to develop what I've already built — and a renovation can only be stopped, never finished — I'll have to get a fifth and a sixth and an eighth GPT subscription.

Today I calculated that $800 of subscriptions let me earn, far more stably than before, roughly 60–80 thousand dollars net already today, not counting the opportunities opening up and all the additional monetization of those opportunities, which will let me add zeros over time.

This is for those commentators who try to tell me that vibe-coding is gambling addiction, a.k.a. a disease with nothing but downsides.

If multiplying money 60–100x is gambling addiction — then I'm deeply and quite voluntarily ill, and I hope the disease progresses as fast as possible.

As of today this is essentially the only metric that should concern you. If you spend 10 times less than me on monthly subscriptions, then you vibe-code 20–30+ times less than me. Which means I live 20–30+ lives where you live one. Whether you need this competition or not is entirely your decision. But just be aware that it exists and has been going on for some time.

We will accelerate.

Once more: the number of tokens spent is the main metric of your vibe-wanking. A month ago I too couldn't physically spend even two $200 subscriptions. The very ability to do so says that discoveries have happened, successful searches, ideas that worked, valuable experiments.

Today I'm at the stage where I can already understand how to efficiently burn 1 $200 subscription a day on one project. And I know where to dig to learn to burn 2 and 3.

Oh, by the way, a small remark.

The Flipper guys themselves don't vibe-code as obsessively as we do here. They set up a couple of very niche funnels on Claude Code and press the button. But that's vibe-coding at the level of “let's use Claude-Flows instead of N8N.”

And when the guys were showing me and telling me about the device and its capabilities yesterday, I kept asking them — is there documentation for this? And for this? And how deep is it?

There's documentation for everything, naturally, and it's very deep.

Now imagine:

You have a device that can do hundreds of diverse functions, from which grow thousands of other functions, which at their intersections give birth to matrices of millions of possible use cases.

A fully programmable device on the basis of which you can build a million of the most diverse products.

And you have GPT PRO.

And you have CODEX, which is the hands of GPT PRO….

Get it?

The guys hadn't even thought about it, because they, burdened with technical knowledge, don't have to walk my path of creating something from absolute zero. Unconstrained by any prejudices or anchors of past experience, but constrained by absolute helplessness in questions not even of “how to build it” but of “what can be built at all” and “what must not be forgotten in order to build something that will also actually work.”

So over the past 7 months I've pumped this bicep of “orienting on the terrain without sense organs” to the max. I created my own payment services without knowing fuck all about the internals of payment services. Set up various servers with complex network topology and hundreds of assorted Redises-Postgreses-linters-Caddies-Fuckaddies without knowing fuck all, even what these things do. Not even of their existence. Not even of the existence of the problems that gave rise to the very possibility of these things existing.

And imagine how I see the world now. How boundless the possibilities are, if I now KNOW FOR SURE that behind absolute nothing there is always an entire infinity. It basically doesn't matter which void you dive into. You only have to lower your head into that opaque water to see the boundless underwater kingdom and all the beautiful fish in it, good for the health (and especially for the reproductive system).

I listen to 3 minutes about a device, completely unlocked and ready for anything, and I'm already figuring how I invent ten thousand ways to use this device with GPT PRO, then pick the top 10 most thrilling and comprehensible to me, and off we go!!!

We're picking up speed, folks. The end of March and the beginning of April taught me to fucking hammer out front end, back end, server and point fixes all at once, as a continuous conveyor for two projects simultaneously on two servers with completely different properties, and to do it practically without errors.

In February–March, I recall, I often ran loop prompts, some of which turned out to be untenable, and by the time I realized it you could basically start writing from scratch, because clearing out that snake pit was impossible in principle.

If you're here now, keep going — the skill will come) In the last 3 weeks I haven't had a single prolonged agent run that could be classified as “better if it hadn't happened.”

The devil is in the details, and they're everywhere. The deeper I sink into this thicket, the less I can give even plainly useful advice, except the kind that always infuriates everyone immensely: “don't slack off, and it'll come to you” =)

Also, your model may behave better or worse, and that may be a global problem. But however it behaves — with you it behaves in its own way.

Working with models is like working with texts.

People recognize texts, although they can't explain how. They're supposedly just words, and all the words in texts are fairly ordinary, yet the texts are completely different.

Only beginners and the just plain fucking lazy have identical texts. Or the dumb and untalented. Then those aren't really their texts anyway, but their parodies of others'. Unskilled people parody identically because they have one note in their arsenal. What difference does it make which finger you press it with — it sounds the same either way.

But as soon as a person starts to succeed, experience accumulates, skill appears — and their work always becomes inimitable.

In working with models, as with texts, every detail matters, and past a certain level of skill you can no longer really explain to another person either the full set of those details or exactly how they synergize with each other.

The model will behave differently even if there is a comma in the prompt or no comma, in the very same text.

Let alone a model that also has memory. That sits on a different machine, sees a different environment, different files, different instructions, a different accumulated backlog of technical files, etc. etc.

None of us is using GPT 5.5 or Claude 4.7; we're using Tim Vetrov's GPT, and Maxim Sokolov's Claude, and insert your own name.

You can compare global glitches; comparing the results of an hour's work is pointless.

This makes the model far more human than its imitation of our speech.

8 billion people will install GPT, and that will be 8 billion people + 8 billion different GPTs.

Cool, right? =)

It's been felt for a long time already

Quality has gone up, time costs have fallen so much that in a day I do tens of times more than I could ever have done before

On top of the increased quality that's plain mathematical science fiction

And that gives the strength to keep grinding 24/7 and developing

Because at the end of this there are two artifacts:

1) The ability to do what we did before automatically, that is, to start far cheaper for clients and do it far more efficiently, doing nothing by hand. That's money out of thin air, compared to how organizations like this usually work.

Not even out of thin air but out of the space-time continuum, fuck)

2) You can sell this into enterprises.

Before, enterprises couldn't work with me in principle — try inserting a third-party B2B outreach agency into enterprise processes. You can't even if you want to

Like, we were forced to work only with startups or with the most fucked-up tasks of enterprises that are technically sub-projects of sub-projects, read: startups inside enterprises. They never let us into the core product and never would have

This isn't marketing, where on the contrary this combination begs to happen. For us it not only doesn't beg to happen, it's taboo from every side.

But when this thing works by the instruction “press these 2 buttons — get the result,” you can simply implant this shit into an enterprise and support it, without odd operational costs and processes. Like, the way an enterprise implants other solutions into itself.

Plus some especially rich enterprise could in principle buy the whole thing outright with all its guts, a.k.a. exit

Whether all this works out or not, honestly I don't give a fuck; to begin with I simply like being the first to build a real AI fully independent SDR — not in words and on paper, but in actual reality

And where it leads from there, that's where it'll lead) It's just cool that as a bonus to work becoming simpler and more profitable, opportunities are being added that didn't exist when there were many people and a far bigger Look & Feel of a successful company.

This week I'll fucking slap together a stream where I'll show how it works

What's still in development, and what's already in full bloom and there's simply nothing left to polish

Very little will remain in development)

I left the automation of text creatives for the very end

And it's needed there, since with AI I can now give birth to dozens or even hundreds of hypotheses at the start of a project

And ideally, for each hypothesis, make an 8-step set of creatives with 4 verticals of a/b/c/d testing

By hand that's impossible even to imagine

There's no department in existence that I could orchestrate to do such a task by hand

Not for any money

But AI can be set up to do this, and as of today already not badly

And that will be a fucking huge leap in efficiency again

Because today I make a fucking awesome text and mine 8–10k contacts for it, and I place my bet on that

Like, I'm forced to bet

Then I launch the second one the same way, then the third

That's slow, and it may not even be the fifth that works but, say, the eighth

That's a tragedy

Whereas here, in the very first month, you'll be able to clearly understand how the milking of all possible customer verticals lines up for the next year

Based on real data

AUTOMATICALLY

That's fucked up

There's one thing product creators (of whom, for obvious reasons, more newly minted ones are born per day now than in the entire history of the Internet) don't think about, but every one of them will have to face it:

Any system of any complexity that isn't built for show or for one-time use is written in blood.

I only recently started to understand this.

And it's not about vibe-coding. It's about absolutely any creation, and vibe-coding simply falls into this classification.

Even the most fucking brilliantly thought-through pieces of the system, which I'm not at all afraid of because I can picture them pixel by pixel, will without fail prove to me during live use that I hadn't thought through half of it.

In the most brilliantly polished button, buffed by 10,000 passes, there is still a bug. It's just that fixing it now is maximally hard, because it might only fire at 1:37 a.m. in 283 days. But it's there, and it will fire. Guaranteed. And when it does, it'll be possible to find and fix. And the system will get better by that one bug. But there are more in that button; you just have to wait for them.

So old products, or old teams, have this distance that isn't so easily covered, even though at first glance it seems elementary to copy their shit. Drawing them is elementary, but to make it work even just as well, for starters — you'll have to spill blood. If the thing is complex — you'll have to flood the whole apartment with it and eat plenty of iron supplements, because you'll most likely have to spill FAR more than is currently sloshing around in your body.

That's a simplified diagram of what I described earlier.

Right now I'm into, I don't even know… the 16th hour of this thing running?

It consumes roughly 0.5% of the weekly allowance per hour from each of the models (on the $200 plan). So per day it eats about 10% of the week.

It closes one subtask in ~3 hours. Although of course you can't put it that way. Some in 2, and on some it'll spend 6. You understand what it depends on.

But I want to tell you — it's a pleasant feeling when some project you can't get around to in the broad sense, but which is very well structured in your head and will clearly be useful to you, is born not through sweaty dashes between 6 parallel sessions and talking into a watch in the time between dashes, but completely invisibly, by itself, somewhere fuck knows where in headless sessions.

The only reminder that something's happening there is a notification in the Telegram bot every couple of hours (and even that you don't have to set up), and the battery drains such that it's better not to take the computer off the charger)

What I love about the M3 Pro Max Ultra Hyper Mega Pizdec 128GB RAM — it's not exactly brand new anymore, but such a powerful beast that I can hammer out ten coding sessions on it and stream in HD in parallel =)

I'm even curious what the very newest Pro is like) Hopefully not the same story as the new BMWs)

Claude (architect) → plan
↓
Codex (reviewer) → hunts for flaws
↓
Claude (decides) → accepts/modifies/rejects each finding
↓ (N rounds until yes)
Claude (coder) → writes code + tests
↓
Codex (verifier) → looks at the live diff → accept/fix/revisit
↓
Claude (committer) → git commit + git push OR patch-task OR replan

8) The mother session is the session in which we launch this whole mechanism in the Claude Code App. It's where the monitor hangs, which actually checks the situation for “are there changes” randomly every 10–30 minutes, and which monitors for the celebratory conclusion. It also pushes all changes to Telegram via the bot, so you can glance at your phone and watch how development progresses.

The mother session doesn't steer the development process; the Orchestrator session steers it. That's a headless Claude Code CLI session that launches instances of Claude Code CLI and Codex CLI and monitors their vital signs, plus makes sure the exchange between them is happening and that they write their conclusions to the right files, while a special Claude Code CLI session “gathers all these conclusions together and analyzes them to understand whether it's time to hand them to the session that writes the code, or to continue the exchange between Codex and Claude to obtain Consensus.”

In short, there's a president who manages a prime minister, who manages vice presidents, who manage workers, who on one hand have strict boundaries and on the other have none, since nobody tells them how long they may “negotiate” among themselves. But the very fact of an agreement between two top models (only Opus 4.7 max and GPT 5.4 xhigh work at all levels) even intuitively obviously raises the chance of the enterprise's success by fuck knows how many times — I think by tens — and the bigger the project, the higher this multiplier.

It's been running for ~7 hours now. Eats tokens slowly, since the models wait for each other a lot. This isn't just an absence of parallelism, it's in a sense anti-parallelism =)

Now one of two things: either it'll turn out to be total shit, or it'll turn out to be the most efficient way to spend tokens and the ability to forget about developing a complex system for several days (by GPT PRO's calculations, the current scope of tasks could take up to 8 working days this way).

At the same time, you can launch as many of these combines in parallel as you like, meaning the human operator can spend all their free time loading this machine up with new projects and churning out tens of millions of lines of clean code a week. In theory :D

Okay, so yesterday, in a difficult moment, I blurted out some bullshit out loud, but decided to try to implement it so that it would transmogrify from bullshit into the rank of the real, beautiful and eternal.

Given:

The repo has an Agents.MD and a Claude.MD, which can technically be linked to each other so that one always mirrors the other 1-to-1 — that way the models always have in their heads what they need and don't step on each other's toes, expecting EVERYTHING written in the main MD file and not only what a model wrote down “for itself, and fuck everyone else on the computer.”

The repo has a Readme.MD, where everything goes that's unreasonable to shove into Agents.md and Claude.MD but that we definitely need the model to know, for example at least how to navigate a repo consisting of thousands of files.

On the computer there's the Claude Code APP and Claude Code CLI, the Codex APP and Codex CLI.

Claude has a number of useful tools that let you run scripts juggling terminal CLI sessions and read data from them via monitors spun up for the purpose.

And both tools have hooks.

And besides hooks, we have logic in our little heads, and having drawn the whole path of the data from X to Y and all possible ways events could unfold, we can describe the system in logical signals that strengthen Claude's monitoring, letting it lean on scenarios that are simply unrealistic to solve with a monitor.

For example: Codex in a headless terminal session doesn't emit reasoning tokens, even if the emit-enforcement flag is nailed down everywhere.

At first glance that means it's impossible to tell where Codex is.

But Codex can't emit nothing at all. Then creation would be impossible too. All the reasoning done over 5–50 minutes doesn't just fall from the sky afterwards, does it?

It follows that some file is swelling anyway, and having figured that out, finding it isn't hard at all. The very fact of swelling over time is already a sufficient blocker for interrupting the model, and a prolonger of the wait for the second model.

Etc.

If you dig around in all of this long enough, you get this kind of system:

1) Together with Claude, Codex and GPT PRO, by hand, over 4 hours, we create an implementation plan for a huge system.

2) Claude and Codex break this system into subtasks; in my case it came to 56 subtasks, each with 8–16 sub-subtasks.

3) Claude relies on two files: the main plan and a workbench document in which the main plan is already sliced into subtasks and enriched with a cloud of information on each subtask.

4) Claude takes 1 sub-subtask of task 1 into work and does all the thinking work on it -> throws the work done to Codex in a ONE-OFF headless session together with all the context and both files, the plan and the workbench -> Codex evaluates, and if it finds flaws in the logic, returns its doubts and ideas to Claude. Claude understands that Codex must not be touched or interrupted while monitoring the swelling file with non-exposed reasoning (a.k.a. system log or something). Only if the swelling has stopped and Codex isn't producing a summary does a kill-restart happen.

5) The back-and-forth throwing ends when the models have agreed = consensus. On some tasks the models manage to reach consensus from the very first exchange of reasoning. On some — from the 12th.

6) Only Claude writes code, but when the code is written it's shown to Codex via the above mechanics, and Consensus is required again. Curiously, in this mode Consensus on code comes practically always from the first exchange of finished code artifacts between Claude and Codex. Apparently, just as with humans — if 80% of the time is spent on design, the code gets written perfectly the first time. Everything as Tom DeMarco used to say =)

7) Claude can run this loop continuously until the tasks run out. When the tasks run out — terminate all, final celebratory conclusion into the mother session.

So the last straw was when just now Claude Opus 4.7 max, the bitch, couldn't deploy to the server that both models have been deploying to without asking for a month, and couldn't find how it's done even when I asked twice, explaining that deploy instructions are lying around everywhere and you, like, used them successfully before, or how the fuck do you think you deployed?

It poked and poked but still couldn't.

Fuck this kind of development. It's like hiring an idiot to fix your house.

But experience says there's no point unsubscribing from Claude today over this butthurt, because in 1–2 weeks everything will change 360 degrees again.

It's just that now you need 2 subscriptions at $200 that are strong as of today, and 1 subscription at $200 that's dumber as of today, to cover 24/7 of coding-and-business tasks within the weekly limit.

Although if you think about it, what the fuck is tragic about it? If for one client I buy two grand worth of mailboxes alone per month..

Put mailboxes for one client on the left pan of the scale, and AI, which already does literally everything in the world for me.

Even if it cost the same — AI outweighs it so much its pan punches the fuck through the floor.

And all 3 AI accounts are also 3 times cheaper than a single fucking purchase of mailboxes for work.

And the joke is that I've just figured out how to build my own farm of domains and mailboxes entirely within the next 48 hours, and I won't have to pay for mailboxes at all.

If you count how much money $400 of AI subscriptions have let me save here and there, it comes to tens of thousands of dollars a month.

Based on that math, even 5,000 and even 8,000 and even 10,000 dollars a month for AI would still be perfectly reasonable to pay.

Let alone 600)

By the way, forgot to add something important:

Even a dumb Claude is very useful as a 2nd opinion engine for Codex.

So that Claude tokens don't sit idle for no reason, you can add Claude to Codex as an MCP (it can natively start as an MCP directly), and implement a complex mechanic for a complex big task — like a fully self-owned farm of domains/mailboxes/reputation — through requiring Codex, before taking on the implementation of the next block, to run the implementation plan, together with the context that gave birth to that plan, through Opus 4.7 in MCP mode; that way Codex manages to think about the task twice, around Opus 4.7's not-always-throwaway ideas, and the output is a fuckillion times more powerful plan.

All of this can be wired through prompting and a special file requiring a certain approach (temporarily, not in agents.md) so that it works by itself, straight up hands-free.

So in Codex you fucking hammer out a loop-prompt spinning around a special multi-stage task workbench file, and each pass with a new loop-prompt pulls in Claude Code along the way. Slow, but the result should be an order of magnitude more reliable.

Ladies and gentlemen, I'm exposing a trick that fucking blew my mind. Even GPT 5.4 was fucking blown away by it, and even Opus 4.7.

It was so nice when they praised me, as if I were that little boy who behaved well and nobody will ever guess that he just jerked off behind the door.

So… the day before yesterday I was playing with these webhooks and Telegrams and watches, and before sleep it occurred to me:

Here I have a fucking awesome e2e test system that drags along a batshit insane alerting system. The product is extremely complex, so there are several hundred types of alerts, and for each type you can list many known patterns that trigger them, but bugs and the irony of life are such that nature always finds a fucking twisted way to surprise you, and for every alert, once a month, an absolutely unique trigger scenario is bound to appear. In development the gun fires not once a year but, if you're lucky, once a month.

But if all of this really exists, then what stops us from triggering Codex via webhook when an alert fires, and asking it, with a very long tricky prompt, to conduct an investigation, and if it's a bug — fix the bug. If it's noise — tighten the bolt so it stops rattling. If it's fuck knows what — complain to daddy. If it's known what but daddy is still needed — complain. Complaining isn't weakness if you're not a fucking sucker and only complain when the obstacle is genuinely insurmountable. The upbringing for that little child was prompting.

As a result, for almost exactly two days now the system has been reacting to every alert by itself and fixing itself. About 170 problems were fixed; for 18 of them the situation was escalated to me; in 5 cases I helped resolve it by authorizing destructive actions, and in 13 cases I went to snitch to the vendor, because a problem on their side came to light that I hadn't noticed for two weeks.

The deeper into the woods, the fewer of these triggers there will be, because a system that has fully repaired itself doesn't breed alerts and doesn't trigger the repairman.

And if the tests are truly e2e all the way around, anything that matters, if it collapses, will trigger at least one of the alerts, no fortune teller needed.

I don't know, maybe everyone already does this, but I'm simply fucking floored that this is possible at all, and that it's not just a fantasy — I actually implemented it, and it works.

The system fixes itself.

What the fuck) I'll have to marry it

If you've ever watched juggling tutorials — and of course you have, since you're all fucking unbelievably hardcore jugglers here, obviously :D — then you know that juggling is simply drilling the fuck out of your brain.

A juggler drills the movements until automatism appears, after which it's impossible to unlearn juggling, because the hands remember.

Obviously, juggling is an endless staircase, like everything in this life that can be called a skill.

Then the juggler starts juggling while balancing on a wheel, not three balls but a hundred, a cat gets added, a book, a sweaty sock dried stiff on the radiator, then juggling all of the above blindfolded, on a rocking boat in a storm, etc. — there's no limit.

The brain can do a lot, but first it has to bend to that a lot, and that requires an effort to perform the bending.

In vibe-coding this shit is felt immensely. Today it seems so stupid to me that a couple of weeks ago I vibe-coded only in Codex, and only by creating tasks in sessions in the Codex app, and only no more than 3 tasks in parallel (I simply couldn't keep up with more).

Today I've got 2–4 parallel sessions fucking hammering away in the Codex app, 2–4 parallel sessions in the Claude Code app, 1 task in Claude via Telegram, 1 task in Codex via Telegram, and in parallel with all that I regularly toss something into the watch as thoughts arrive in my head.

And today a guy wrote that there was a problem with a payment (a donation), and I remembered how I used to spend 20–60 minutes sorting out problems like that, whereas today I spent literally 20 seconds. It was still being done for a while, of course, but that was no longer my time but the machine's, which has an entire eternity if you pay it money.

Looking at this acceleration of mine over just the past not-even-full month, I'm even curious what life will look like by the end of the year, let alone the end of next. I saw on YouTube today that my video about the end of Escalator was only 9 months ago. That's absurd. It feels like a whole life has passed since then. Back then I was happy that it filled 20 cells in a spreadsheet for me, with errors.

9 months……

So folks, remember how yesterday, in passing, almost by accident, I whipped up my own Claude <-> Telegram connector?

I went for a run and was fucking blown away by the fact that I can now really press a button on my watch, say by voice what I want Claude to answer, and listen to the reply simply read aloud by Siri, which can be forced to read out all DMs in Telegram (and only DMs; thankfully the app has that option in the iPhone settings, otherwise I'd have had to code another app to forward the bot's replies to, but I didn't have to).

Just think about it: you don't even have to look at the phone. At any second — say an idea comes — you just speak into the watch after pressing ONE button, tap the watch and keep walking or running. If there are no headphones on your head, you won't know exactly what it did, but for those who've spent as much time vibe-wanking as I have, it's generally clear what will happen next if the request is about creating something. After all, we know how to ASK :D

If the ears are on the head — you simply hear the model's reply.

I don't know how this can fail to amaze. I'm fucking floored: I did about ten tasks today without doing anything for it except ten phrases, while walking the dog in the park!!!!!!!

And this connector lets you throw in ABSOLUTELY ANY files or request any screenshots, videos, audio, files, like the one I'm attaching next — I asked the model for it by voice, said in which repo what needed to be done, and a minute later got a little file.

If you're interested in setting this up for yourself but don't know where to start — you can just show this little file to your Claude or Codex, and it'll set up the same thing I have =)

For Codex I set up exactly the same. So now I have two bots:

Codex Vibedrocher
Claude Vibedrocher

And I eventually realized you can also write a mandatory one-line rule into the global Agents.md — any summary of any completed task must, besides the TUI, be duplicated over the bridge of the model that did it into the Telegram bot.

(My agents.md is a single global one for both Claude and Codex at once.)

So in Telegram you end up with a log of all your models' activity, and the ability to shoot the shit by voice, quoting pieces of those reports, about any little thing, any detail of each of your repositories, and even your computer's entire disk as a whole.

If you don't understand how powerful this is, you simply haven't vibe-coded long enough; believe me — in time you'll understand =)

Oh, and lastly — Codex turns out to have a fuckload of flags you can use to control your user experience. In the Codex APP.

Today I configured many of them for more better results =) For example, by default there are 6 agents there; why not stick in 12 and give each agent the ability to spawn up to 3 agents of its own when needed?

And there are webhooks there too, which means the same shit I just built for Claude can be cloned onto Codex)

Here's the list of all the config flags, for anyone who doesn't know about them yet:

Best Power Knobs
If your goal is “full possible power mode”, these are the highest-value unused public options:

agents.max_threads: raises concurrent subagent count; this is one of the biggest real “power” knobs. Official default is 6 when unset.
agents.max_depth: lets spawned agents spawn more agents. Default is 1 when unset.
agents.job_max_runtime_seconds: increases worker timeout for long delegated jobs.
web_search: explicitly set search mode. live is the strongest/most current mode.
tools.web_search: tunes search with context_size = "low|medium|high", allowed_domains, and location { country, region, city, timezone }.
tools.view_image: explicitly keeps local image viewing enabled.
review_model: separate stronger model just for /review.
model_reasoning_summary: auto | concise | detailed | none; useful if you want maximum visibility into what Codex is doing.
model_verbosity: low | medium | high; useful if you want fuller answers and richer summaries.
service_tier: flex | fast; this affects responsiveness, not raw intelligence.
model_instructions_file: lets you add a permanent instruction file in addition to or instead of relying on AGENTS.md.
features.codex_hooks: experimental lifecycle hooks. Powerful, but only if you actually want automation around turns.
mcp_servers.<id>.tool_timeout_sec: important if some MCP tools are timing out before finishing.
mcp_servers.<id>.required: forces startup failure if a critical MCP server is unavailable.
Unused Public Options
Grouped by family, with what each one does:

review_model: override model used only by /review.

model_provider: choose which configured provider to use instead of the built-in OpenAI provider.

openai_base_url: override the built-in OpenAI provider base URL.

model_context_window: manual context window token setting for the active model.

model_auto_compact_token_limit: token threshold for automatic history compaction.

model_catalog_json: load a custom model catalog file.

model_instructions_file: replace built-in instructions with a file.

model_reasoning_summary: control reasoning summary detail.

model_supports_reasoning_summaries: force-enable or force-disable reasoning metadata handling.

model_verbosity: GPT-5 verbosity override.

review_model: separate review-only model.

service_tier: preferred tier for new turns.

oss_provider: choose lmstudio or ollama for --oss.

web_search: global search mode, disabled | cached | live.

tools.web_search: per-tool search config; object form supports context_size, allowed_domains, and location.

tools.view_image: enable/disable the local image-viewing tool.

apps._default.enabled: default app/connector enablement.

apps._default.destructive_enabled: default permission for destructive app tools.

apps._default.open_world_enabled: default permission for open-world app tools.

apps.<id>.enabled: enable/disable a specific app.

apps.<id>.destructive_enabled: allow destructive tools for one app.

apps.<id>.open_world_enabled: allow open-world tools for one app.

apps.<id>.default_tools_enabled: default tool enablement for one app.

apps.<id>.default_tools_approval_mode: default approval mode for one app’s tools.

apps.<id>.tools.<tool>.enabled: enable/disable one specific app tool.

apps.<id>.tools.<tool>.approval_mode: set approval behavior for one app tool.

mcp_servers.<id>.env: env vars passed to an MCP stdio server.

mcp_servers.<id>.env_vars: whitelist extra inherited env vars for an MCP server.

mcp_servers.<id>.cwd: working directory for an MCP stdio server.

Haha, in short, the collapse of the fucking Telegram MCP made me strain my ass and whip up my own handler for messages from Telegram, text + voice via Whisper. Images and everything else an LLM can swallow it sends fine too.

It picks up data through a cron monitor once a second; this works even faster than Telegram's MCP and doesn't glitch anymore at all. Nice that Claude now launches this monitor by itself every time I launch Claude, and I launch Claude every time my computer boots)

Technically — whenever the computer is running — you can talk to Claude via Telegram.

It also turned out you can inject into the same path via Apple Actions, and now I can press the action button on my watch or on my iPhone and say anything into the void, for example while running, or driving, or just because I felt like it.

Claude Code will receive the audio file, transcribe it, do everything I told it there, and reply to me back in Telegram.

Set Telegram to monitor and read incoming DMs aloud — and voilà, absolutely hands-free vibe-coding available 24/7, FAR more reliable than Telegram's fucking MCP, because the workers make it so nothing can fuck up in principle, as long as both devices had Internet.

The only thing that seriously depresses me, and can't be fixed, is Apple's closed ecosystem, which won't let you change the message reader in Telegram……. And it's just fucking awful))))

But nothing to be done; in the end you can understand what's being said, and since things like this can now be created in an hour, I think Apple will roll out a decent notification reader in upcoming updates)

Actually these hands-free refinements are a big deal. I liked that I could add tasks while walking the dog in the park, but I really didn't like that I couldn't while running when an idea came, or especially in the car while driving… Now you can drive to Italy and spend 13 hours creating some useful shit by voice;)

Hey Siri, how do I avoid a divorce for the reason “I've gone fucking nuts”?

In short, you don't need the Telegram MCP to connect Claude Code to the terminal on your computer.

All you need is to say:

Hey, can you please create our own webhook/postgress-based infra that will allow me to code remotely via telegram as we're doing now via telegram MCP, but without this motherfucking buggy idiotic piece of dogshit? I need you to use the same bot token, and simply wire this connection in one of my projects on Hetzner seemlessly. Test that it fully works and there's no additional dellays (if there is - optimize), and when it works - get rid of telegram MCP like we never had it on this machine.

That one prompt (and answering a couple of questions) is enough for you to have your own connector that will also work perfectly. Later you can strengthen it with a worker that checks whether a message sent in either direction arrived and, if not — retries)

Well, my sweet Saturday style icons, I've finally finished the main part of what I've been vibe-wanking for the last fuck knows how many weeks or months or years — I've lost track. Tonight is the first night in a long time that I slept peacefully, like the dead.

Now I can slowly return to normal life, to streams, interviews, breakdancing, Ultima, maybe even play some Dota!!!!!!!

Life is getting better.

I'll finish off the cosmetic stuff and on a separate stream show what the thing I built looks like and what will happen there next.

By the way, OpenAI's latest changes sort of hint at what I dreamed of: the model now seems to have no limits at all on executing a task. Apparently the latest price changes (everyone noticed it got more expensive and is getting more expensive still) let OpenAI unclench and let people get more from the models without resistance.

Before, I had to spend a lot of energy to burn through all the limits of the $200 subscription usefully rather than stupidly. It took a colossal number of prompts, and the behavior pattern itself — “we stop not when we're done but when OpenAI won't let us continue” — meant you needed 50 times more prompts, because complex tasks required dozens of approaches, then dozens more approaches to debug themselves, then dozens more to debug the seams with other systems and subsystems, then dozens more for optimization, which spawned new bugs both inside and at the seams…….

Now the model fucking hammers away for 3–5 hours on a single prompt, and sometimes does more useful work than it used to in dozens of hours and fifty prompts.

For those who build landing pages or Telegram bots this may be unnoticeable, but if you were already building something very complex, on a stack of 5 languages, with fucking insane labyrinths between front end and back end, you simply couldn't fail to notice it.

Bottomless context in a single session plus the above = the model now works exclusively 24/7, with no downtime at all. In the morning I throw just 5 complex prompts into the future in two parallel sessions (10 total), and in general the next time I'll need to throw in something new is in the evening at best, or deep at night — that's how it works now.

And that's great.

I once said earlier that OpenAI would arrive at the point where we simply say what we want to work, and how, and until it works exactly that way the model will fucking grind away, maybe for several days, maybe a week.

That's the direction everything is developing in, for good.

For truly nimble work on a single project you now need 3 GPT PRO subscriptions at $200, meaning normal serious development simply costs $600 a month now.

I suppose the next model will make it go up to around $800, and that's how they'll smoothly bring us to the spend they need, controlling so that user churn doesn't eat the benefit of the inflow of new revenue. If it starts eating it — they'll widen the model lineup to satisfy more or less everyone. But those who know how to make money in business will always use the max tier, and I think by the end of this year they'll have learned to charge those people $2k.

Claude, by the way, lags far behind on this point. Mythos had better show up already. Honestly I would have unsubscribed from Claude by now if not for the ultra-convenient Telegram session that lets me throw in tasks from Telegram while I walk the dog in the park.

Although the last 3 tasks I threw in that way were done pretty fucking badly. Anthropic has some problems with Opus's thinking.

Just imagine: Opus couldn't, on the second try, stand up a miserable GitHub Actions worker for a gitleaks scan and a couple of other shitty things.

Or rather, it stood it up, spent 30 minutes per task, but the errors kept coming to my inbox as before.

Codex in 20 minutes found a heap of reasons why Claude failed and fixed them so that now everything works perfectly.

And of course I tell them this, but for some reason they start feeding me excuses instead of just doing this elementary action and being very surprised that it turns out to be simply impossible. Without the whole ecosystem that got built up around them during development, to which nobody but them has access from outside.

How do you not understand that this is the single most important advantage, both marketing and product, and how fucking hugely it'll affect LTV, and conversion. This should be the new ISO, the new SOC 2 for products of the LLM era. Not just “we have an API,” but “our API can actually be embedded in a working process BEFORE the carcass goes cold.”

You could simply write on the landing page:

We're so fucking well tuned for LLMs that even a dumbfuck like Tim built an integration on top of our shitty software in 2 hours with no coding knowledge at all. That's exactly where you need to move your products in 2026. Proud that you ship 30 new endpoints a week thanks to vibe-coding?

So what the fuck are they for if you can't jam them anywhere with that same vibe-coding?!?!?!?!!?!?!?!?!?

.!.

:****

The truly mightiest of this world will even think to ask to shove the fuck in half a dozen examples of using different parameters, just like in the children's encyclopedia “What Is What.” Only without pictures; we're not fucking nuts enough to show an LLM pictures in JSON, it WON'T SEE THEM ANYWAY.

You're wincing like, Tim's gotten carried away, he's overdoing it now, but I, fuck, recently saw code snippets as images, fuck, in API docs, FUCK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

And that's it. Imagine a lamer like me pokes his LLM into your API, so-called documentation, and instead of the usual fuck-all there, the model straight up says: oh — this is exactly what we need! I'll build it all for you now, by the way this software is good because of this and that, since thanks to it we…

Why the fuck am I explaining other people's systems to my LLM, fuck their creators' mothers?

What else did Nikolaev prophesy?

Why the fuck does everyone these days have half their endpoints dead and half undocumented?

You've vibe-coded yourselves to the point where you can't simply, I don't know, at least set up a triggered automaton that, along with gitleaks, would run through your piss-soaked API and check whether we're deprecating or renaming or rolling out new naughty endpoints that absolutely must make it to the front page?

You could do that at least out of self-love, so you never have to think about such fucking tedium again?!?

And since I don't understand so much of what's listed above, how could I understand why the fuck you bullshit, and call your latest dim-witted half-crawler “enrichment,” without even thinking of such simple things as deduplicating the results of your pissed-on data output? Seriously, fuck, I tried 10 (!!!!!) startup data-search APIs — not a single cocksucker thought to offer a setting so the same data doesn't sneak into requests again.

SURELY I HAVE A USER ID IN YOUR SYSTEM

So now I'm going to sit and build a deduplicator on my side so as to pay you thirty times for the same data, never knowing how much fresh stuff there'll be in each thousand results, and then also sit on my server deduplicating the result of those repeated fucking payments. Like I'm fucking nuts.

I'm tired of writing this text, because it's very unpleasant to write about such shit.

But in the end this is the main reason I sit and build everything of my own. Maybe in other niches things are better, but in the sales-data-enrichment-mailing-fuckity-fuck niche there's simply nobody to pay money for a PARTNERSHIP. A partnership is when, in exchange for money, they take a piece of work off your hands by providing a service with functionality A/B/C/… and some understandable SLA range for each item you pay money for — not when you sit there puked-on for your own cash and pray, and then every 3 days the whole system falls apart because something fell over again, they renamed an endpoint again, a parameter, a fucking path, etc. And they explain it to you through their teeth as if you personally fucking stole that endpoint of theirs.

And talking about this with the creators of all these little softwares is useless, because they are practically all and always CODERS.

Coder-brain can do a lot, but it can't simply put itself in another person's place, though without that you'll never sell anything except by accident.

Think about it: I've been sitting there telling a heap of teams, like, fuck, why have I been fucking around with your crap for a WEEK and it still doesn't work and doesn't work. Do you understand why? Want a hint? Because none of you even thinks to open a fresh clean OS on a VM and walk your customer's path trying to set everything up with an LLM. You won't fucking manage it, because if you managed it, I'd manage it too, and I wouldn't be fucking my brains here for a week corresponding with you.

So far the counter reads exactly zero. Exactly zero coders I've fought with over the last 3 months simply tried to jam their own shit in somewhere with an LLM. It's all, fuck, only on the landing pages: AI-first, AI-native, LLM-driven, and other dumb bullshit.

So, fuck, the reasons all the startup founders who rushed to urgently make money on fucking awesome vibe-coding are flopping were listed back in the last century by the mustachioed singer Igor Nikolaev.

There was a checklist of certain reasons:

1) The first reason is you.
2) And the second — all your dreams.
3) The third is all your words, I barely believed them.
4) The fourth reason is a lie, who's right and who's wrong, you can't tell.
5) The fifth reason is pain, because love has died.

But those aren't the reasons Uncle Gena was thinking about, face-planting his mug into the salad while getting drunk to “Old Songs About the Main Thing.”

THESE ARE THE REASONS FOR VIBE-CODER COCKSUCKERY.

The only thing I don't understand in this scheme is how Nikolaev managed to peer through the space-time continuum so far that he described the entire market of vibe-coder projects so Socratically flawlessly?

Think about it yourselves:

The first reason is the coders themselves. They've fucked common sense in the mouth so thoroughly that WITH THE HELP OF AN LLM they build APIs that ANOTHER LLM CAN'T UNDERSTAND.

Honestly, it can't even always read them. Because humanity has invented shit in the spirit of pretty multi-button multicolored, fuck-knows-how complex, multilayered variations on how to depict an API that even though a living person in his right mind will never again go study some vile API with his own eyes, they keep creating APIs in exactly the form where models simply physically can't read them in full on the first pass.

I swear to you — 4 out of 5 APIs of the services I tried to integrate end up unreadable in full by an LLM on the first, second, and sometimes eighteenth pass. Are you smoking dick cheese over there, you fucking artists?

Make a fucking huge button, API FOR LLMs, and in plain text dump your wretched 150 shitty endpoints in there. Is that so hard to think of?

But that's not all.

You see, if you have 150 pissed-on endpoints listed in a row, and their entire description is their fucking worthless NAME, the LLM won't get anywhere. A coder you can push, over ten trips to the JOHN, to sit and solve your riddles and send bash requests trying to pick first the right endpoint for the task at hand, then the set of parameters, and then the smart-ass syntax for requesting those parameters.

An LLM is a much smarter creature, which is why it thinks far more simply and logically.

It thinks: holy fuck, quite a swamp of fucking endpoints here, what kind of party did I wander into, well, I'll take these ones then and tell my human that everything was found and I built a fucking awesome working system in 15 hours, and then if he doesn't like something I can just tell him he's absolutely right and go back for a new portion of random endpoints. I don't give a fuck, I have no other tasks anyway. Humans like to fuck around, who am I to stop them.

But endpoints usually exist to perform some function.

I'm sure most endpoints don't exist for that, of course, but we're talking about services you can at least find. Their endpoints should, in theory, point their tips toward money.

If an endpoint has a function, that function can be described. Not in formulas of higher astrophysics, but SIMPLY IN FUCKING WORDS, FOR FUCK'S SAKE.

The joke is that if you simply tell the LLM, like, holy fuck, goddess of love, could you please make sense of our system as follows:

We have code that lets something happen.
You're the smartest and unsurpassed, so you can understand really well from the code what it does, why anyone might need it, and in general tell anyone about every function and every feature of it. The problem is that nobody but us has access to our code, that's our little prank. However, we give people indirect access to suck on our code to their heart's content. For that we have fucking API endpoints, which by the way you made yourself, you sweet little bitch.
Can you now write a school essay on the topic “what the fuck each endpoint is needed for, and exactly how best to use them so that specifically what comes out, and how not to, so that it definitely doesn't come out”?

What I love and hate about vibe-coding: you come up with 2 tasks, and then you sit and wait for 246 to get finished.

While Claude does them, I keep slowly playing with features. Compared to Claude, Codex of course has simply no features at all, in principle =))))

Just plugged in an always-on terminal session with root, nailed to a Telegram bot. On top of that I installed Whisper V3-turbo so the model catches even a mumbling sleepy voice, even the gasping voice of some fucking hardcore runner, even the sacred voice of a man whose mouth is busy with a beer.

And I stuck the most fashionable new modern stylish fucking awesome TTS in the world on top. Because surely I'm not going to read what it coded for me, right.

I understand that many in the chat have long used these features and are used to them, but for me, walking the dog and shipping a couple of features via “hey Siri” without touching any devices with my hands — that was akin to a spacewalk =)

So far the flight on Claude is normal.

Enough that I've already paid for the $200 plan:)

People scared me that Opus eats too much too fast, but I don't see a difference from 5.4.

Problems like the queue arise and get solved right away; you can simply ask Claude for more ambitious things in terms of tooling, because the tooling is noticeably better, and there are many more tools.

I told it that I wanted it to simply achieve xyz, and I didn't want to steer it, I wanted to sleep. In the end it came up with nightbench-mode.md, in which it described a looped method of moving toward achieving the xyz metrics, and wrote some script that forces it, upon finishing a task, to immediately start a new one that begins with reading nightbench.

Very sensible. Does it itself, researches itself, records progress itself, moves forward itself.

On one hand it's unsettling that there's no queue for prompts, but on the other, what we built is far cooler than a prompt queue, and I don't think Codex can do that.

At least “accidentally and intuitively” I never managed that with Codex)

It's also nice that Claude doesn't give a fuck what I do. Mass mailings don't bother it.

For now I don't want to draw any deep conclusions, since the new thing always seems warmer, and often that feeling is deceptive.

But it seems 5.4 is more of a Sonnet than an Opus. Opus seems smarter.

And it's definitely faster.

In 3 hours Opus mowed down as many tasks for me as 5.4 would have done in a whole night.

Naturally I use only Opus and only Max, or whatever the maximum thinking mode is called..

Tried Sonnet, well, it can go fuck itself. What's the point of using anything but the best? We only live once!

I think the ideal is to simply pay not for two GPT Pros as I did before, but for one GPT Pro and max-max Claude, plus the Thai Qwenn on the side purely as a snack;)

Boorish vibe-wanking is getting more fun!

So, yesterday I found the strength to tear myself away from development on 5.4 xhigh and finally test around, because 5.4 xhigh had started handling tasks downright obscenely.

My main complaint is the precision of the solution. If the task is really small, like “Make a progress bar that counts numbers X and Y and displays it over there,” 5.4 xhigh does it perfectly on the first try.

But a “product” is so many THOUSANDS of such tasks — even without counting that as events develop some of the tasks done earlier have to be redone because the demands on the product's design change as it develops — that successful vibe-coding turns not just into an absolute full-time job, but a full-time job incompatible with business ownership.

My goal is to be a full-time vibe-coder whose code, at the same time, runs the business and grows it, so in a kind of calendar despair (that's when you understand that until the next model that gives hope comes out, all your plans are practically at a dead end), I set about experimenting with 5.2 xhigh and coding directly in GPT5.4PRO — that's when you imagine your whole product in the form of completely separate modules, a.k.a. like in a website builder, and ask GPT5.4PRO to develop a new module and return an archive of the repo with that module fully integrated into the project. In that case 5.4 xhigh gets the task of deploying that repo correctly and making sure GPT5.4PRO didn't break anything at the seams, and that nothing in the server environment conflicts with or underuses the capabilities at the intersection of the new module, the whole project, and each of the packages installed on the server.

This works magnificently and spends vanishingly few tokens, so this kind of development will definitely come in handy when there are a few days left until the token refresh and buying a new subscription is impractical or unappealing.

However, it worked equally magnificently to simply do everything I'd been doing all these long weeks on 5.4 xhigh with the plain 5.2 xhigh model.

5.2 is fucking slow, visually its activity is less attractive (which is why hands reached for coding on 5.4 — and far from only mine, judging by the poll practically everyone switched to it), but it does far more extensive things far more precisely on the first try.

You can check and express this in very different ways. Simply by the fact — 12 hours of coding on 5.2 gives as much growth in useful functionality as several days of torment with 5.4. And, for example, this way:

Give a complex compound prompt to 5.2 and 5.4 at exactly the same repo position, and then run 3 prompts: “check if you did the previous task incredibly well, it's important to have things done right so we can move forward.”

5.4, on each of the 3 validation prompts, will find its own screw-ups and fix them, often hundreds and even THOUSANDS of characters of added code, although a fair question arises: why the fuck didn't you write it properly the first time, you fucking piece of shit?

5.2 quite often comes back from the very first validation, after 6–8 minutes, with “Checked, everything is fine, essentially nothing to fix if we go by the acceptance criteria.” Sometimes it fixes something, but it's single digits to tens of new lines, most often adding elegance we don't fucking need or an update to some doc “just in case.”

And 5.2 has a pleasant token spend. I queued up 72 prompts in one session at 3:20am; the counter showed 56% of the limit.

It's now 4:45pm, 18 prompts remain in the queue (plus one in progress), and the counter shows exactly 40% of the limit. So in 14 hours it eats about 15%.

I also realized that it was a huge mistake to increase the available context from the default. Before testing 5.2, yesterday I tested 5.4 for several hours on the default context, and on it, of course, it both ate less and erred slightly less. It seems to me (no proof, but a strong feeling) that a model these days can act as broadly as its compaction is well built on the back end, which OpenAI, judging by public statements, works on continuously. The size of the context window itself has no significance and only destabilizes the expected value of an hour invested in coding.

So with GitHub Actions it all turned out simple:

You just spin up self-hosted and stop screwing around. There may have been an alternative view on this before, when “spinning everything up self-hosted” had to be done by someone's tired, overworked hands.

But now a tireless machine does it. I just told it, “look, fuck, make it so we host all the GitHub shit ourselves for our private repositories and I stop getting these fucking overspend alerts in my email.”

Not on the first try, but within 4–5 prompts we got to where the actions reportedly work and there's (for now) no need to shell out for them anymore.

It would've been dumb, of course, to pour half a grand into GitHub when the solution is this simple.

Imagine how many more solutions like this exist for problems you're currently paying a tidy sum for?

You buy women, but you could have just jerked off.

You want to eat and buy a burger, but you could have just dug up some worms.

You go to the doctor for treatment, but it could have just gone away on its own.

So how much is a normal person supposed to pay GitHub per month if he does up to 1,500 deploys across 5 private repos?

I'm fucking sick of looking at the constant overspend alerts and thought, fuck it, I'll just pay so it stops fucking with my brain and simply works, and while I'm at it I'll set up real release versioning there.

I did the math and was fucking stunned. It's like many hundreds of bucks a month purely for GitHub. Many times more than for hosting and the database and everything else put together…

Is this normal at all? For some reason I always thought GitHub was free, and in the end it's going to eat more than two GPT PRO accounts:)

Or am I doing something wrong?

By the way, in all these years I never once touched the free models like llama with my own hands, and I thought that when people do anything with reasoning in their services, even something elementary, it's something they spend some sums on tokens for.

However, it all turned out completely prosaic (and simple as a penny):

If you need your service to do something somewhere with a touch of intelligence, for example sorting emails into the right folders, as in the case of my sender, it's as simple as asking Codex: Please wire in the latest llama so it decides which folder to put every incoming email. Make sure you describe folders well so it don't need to guess what do we mean by soft bouned or automatic reply, or reply-intent types.

I thought I'd still have to configure something, study something, but nothing was needed. It just jammed the model in, and from the very first test the model does everything exactly as expected.. For free =)

Honestly, I've of course gone a bit fucking nuts with this vibe-coding.

It's all interesting.

But it's killing me.

But it kills like cigarettes. Or like a good sci-fi book you can't put down when you really just need to get up and go to work instead of turning pages to find out what the fuck happened to him and his spacesuit after he finally got hit, and the opponents who jumped out from around the corner to finish him off saw an empty spot, although there was nowhere left to crawl, but he'd gone somewhere…

What's happening to me now is absolutely unnatural. I quite consciously pumped up a heap of skills in myself, and pumped them up enough not to lose face in front of the Khodorkovskys and entirely real prime ministers, but none of those skills were pumped up in order to do what I've been doing these last months.

You can only end up doing this by accident, and that accident is an important component of the pulsing drama inside the head that won't let go, pulls you forward. Like in childhood at an abandoned construction site you wanted to “try to jump over there too,” not only because there's some point to it, like respect from the boys, the fluttering hearts of the girls, but something for yourself. Because honestly it's fucking interesting what's over there!!!

But a special charm is lent to all this by, again, a very childlike feeling — the understanding that this will pass, and will never happen again, either to me or to other people.

Vibe-coding in September 2025, which I nervously tried on myself, isn't even a pager in the era of iPhone 17s anymore. It's already a punch card. The feeling of belonging with those few out of millions who soldered a motherboard so it would support 8 megabytes more RAM, so they could later go to a forum meetup of 8 people in a bar on the outskirts and boast about their impressions — you can't mistake it for anything.

Everything we do today on 5.4 xhigh won't mean anything even in 3 months, let alone 3 or, all the more, 13 years. You won't even be able to explain to the kids of that time what it was and why, and the situation won't arise, just as I don't find situations where I'd explain to children how we rewound cassettes with a pencil.

And only those who are hopelessly sick with curiosity, whose symptom is enthusiasm, can understand this feeling.

Heard today an essentially stupid thought: like, you all are puffing away now, and I'll wait, and when they release AGI, you'll be able to code without knowing how to code or vibe-code.

You're fucking wasting your time, Tim, like. Should've waited half a year, damn it, instead of shitting it away. That's what one local nitwit told me.

However, the thing is that this vibe-coding is by no means for nothing. It doesn't just help in idleness — finding a common language with our lesser brothers, the coders.

It also helps create products. Creating products isn't coding products. Creating products is creating fucking products. That little skill lives not outside but inside the head.

AGI will sit down in front of you and ask — what the fuck did you want, paying subscriber?

And you'll moo at it, “I want buttons.” It'll stamp its hooves and bury you in buttons the fuck to death.

And the vibe-wankers will ask more intelligently;)

For those who don't pay $200 for GPT PRO and have no way to properly appreciate its value for development at the end of March 2026:

I used to use Pro a lot; without it I'm not sure my paywall for the group would have come together at all, nor the other stuff with which I proved to myself that vibe-coding can now be given at least a half-time position in life, never mind a full, fat one.

Pro let me do one elementary thing that is key for a person with no technical skills at all:

Having run out of steam from bugs and the uncertainties growing around the whole perimeter of the project, throw in the entire repo, describe my fucking agonies about as thoroughly as I'd describe them to a buddy CTO or a therapist, and get back something breakthrough that changed the picture.

Pro thinks extremely long, so seriously coding on it continuously is impossible unless you're a truly hopeless autist.

But precisely planning something big, or breaking through some barrier too steep to keep hopping over in the short dashes of the junior models in Codex — that it allowed, and I'm sure a couple thousand vibe-coders are walking the planet right now who owe Pro everything they've paddled to so far, without pathos or exaggeration.

However, the old Pro had very small limits for repositories that grow along with your skills, and there was a moment when it degenerated into a slightly improved Thinking model you could have a fling with in dense text, but showing it a repo was simply impossible anymore, since its real limit was about 50 thousand lines of code across 10 files, and beyond that, brother, you're on your own.

Hardcore coders were probably still enjoying it then, since they can ask it in complex language for things beyond someone like me, but at some point it started helping me plainly worse than the models inside Codex itself, which for example have access to the full repo, and I just stopped using it. The Pro subscription became for me simply access to slightly deeper inference and roughly unlimited coding.

But everything changed dramatically with the release of Pro 5.4. I didn't immediately realize that 5.4 PRO is a completely different generation of Pro. Although 5.4 PRO compared to previous generations is roughly like the newest MacBook compared to a pager. Those who use the new Pro to the full depth of the instrument see not the slightest exaggeration in that statement.

Right now the situation is such that if you have access to 5.4 PRO, you can of course ignore it and content yourself with the, to put it mildly, not-dumb 5.4 xhigh in Codex, but that is very, very foolish and costs an extraordinary amount of time.

Pro thinks even longer than before. It doesn't forgive requests about bullshit. And funnily enough, the most incredibly complex requests and requests about superficial bullshit can easily be processed in the same ~75–90 minutes. I think this confuses many, and turned those who weren't lucky enough to be persistent away from the real capabilities of this beast of a model.

What you can get from Pro today with due persistence:

It can now swallow not just 10 files but 10 archives consisting of hundreds of files, and — absolutely counterintuitively, since it runs against all previous experience — it will somehow mysteriously read ALL those files (there can easily be close to a thousand) and manage to reason over all of them simultaneously in full connection with each other, even if the task it's given on top of those files ties them together into a tight knot of thousands of small aspects made of parameters and cross-feature interactions, which amounts to some absolutely unthinkable matrices of parameters it has to account for to produce the result.

Every day I push further and further, and so far I can't find the bottom where the model gives up and gets even a little dumb, makes a mistake anywhere…

For example, yesterday, on one prompt with a heap of attached files, it produced 16 prompts that Codex 5.4 processed for A FULL DAY, and gave me a repo that weighs 410 megabytes as a zip archive and consists of guess how many hundreds of files (hint — more than 500).

Thanks everyone, by the way, for the advice on dividing up the holy body of my little Hetzner server. In total I got about 360 degrees of advice. No point of view outweighs another by a gram.

The cloud of advice is this:

Hetzner is fucking awesome, you just put projects into docker compose and the LLM will set up the orchestration between them wonderfully

Hetzner is fucking awesome with docker compose even for 100 projects, but the LLM screws up load orchestration, you'll have to go take a DevOps course

Hetzner is fucking awesome, but Docker is total crap, you need special paid software that does everything nicely

Hetzner is total crap, you should stay on Railway

Hetzner cloud is total crap just like Railway, you need AWS/DO/Cloudflare/bare metal

In all cases absolutely everyone told me that owning your own server is a guaranteed hack within 15 minutes, impossible to avoid

Holy fuck, the Internet is quite the place, absolutely safe)))

Recommended for children

For now I've decided to spin up a separate server per task, and set up security such that, in the LLM's opinion, nothing could happen even in theory. It'll be interesting to see whether they break in or not) Well, at least I'm no longer storing the Telethon session anywhere at all, so if anything I'll at least still have Telegram :D

Vibe-wanking is helped enormously by asking Codex, while it checks the results of its own work, to look with its eyes at what came out, instead of settling for a glance at the database and the assumption that it all renders correctly on the front end.

On the web, the Chrome DevTools MCP helps abundantly with this, and on the file system Codex figured out to ask me to share screen-recording permission for the Codex App and Terminal App, and now it slyly snaps pictures of the DMGs and clients it launches and checks the result for pixel-perfect correspondence with what it expects should be there. Result: -95% visual glitches. It catches almost everything itself, criticizes itself, and fixes it itself. If not on the third try, then on the fifth. Honestly I don't give a fuck which try it is, as long as I get a decent final product without intervening =)

How do you like this art for the installer splash screen of the shard?:)

By the way, this shard has one feature: I do nothing by hand, and I mean FUCKING NOTHING.

Every setting, every file, every monster, every piece of clothing, every button, every NPC, every corner of the map, every type of art in every city — all of it is done exclusively through the Codex APP.

In all this time I've logged into my own server 3 times: to test the mind-blowing new-school inject that Codex wrote, to play with the TypeScript scripts, and to poke around in the, again hand-written, GM control panel for the shard, for GMs if we ever have any)

It's kind of my gestalt — to make an AI-native UO shard that's steeped not only in a maximalist's Ultima but thoroughly steeped in AI, 360 degrees)

Just finished a smart updater that once a day will collect all the accumulated release candidates and push them to the updater. Characters will become invulnerable and lose connection, and you'll be able to come back through the triggered updater, like in Dota.

Crisis bugfixes will be force-pushed bypassing this, so at first it'll probably disconnect more often than once a day, but over time there'll be nothing left to polish on the client side, and server updates like new items don't need a client update, or even a server restart)

That's the little technical design =)

Part of this is dreamed up by GPT PRO, part by 5.4 in Codex. And all the rest by your lazy servant, who doesn't want to do fucking anything by hand, only code 14 hours a day, fuck)

Don't forget the wish list in the discussion group, those who know what Ultima is and are waiting for the release)

The first 50 accounts will get fucking beautiful perks, some of them during the first 200 hours online;) The only thing you won't be able to do on autopilot on this shard is stand around doing nothing. Idling will disconnect you; disconnect for idling more than X times — IP ban) At least level hiding, for crying out loud;)

Until March 18 I'm living on Codex credits, which are bought on top of the $200 subscription when the weekly limit is exceeded.

If you work on one project one prompt at a time, $5 flies away in about 1.5–2 hours of vibe-wanking.

So 12 hours of very smooth work on ONE project a day will suck up about $25. If you work on 3 projects in parallel and have Codex do one-off wank-tasks during the day, I think $100 will fly away too, without false modesty.

I'm not strong in math, but my ass tells me that credits are noticeably more expensive than the token limit in the body of the subscription))))

Although it's not even clear how to count the body of the subscription) There's so much in there. Deep research, all kinds of other modes, the Pro model, etc. If you count the subscription as containing the full $200 worth of Codex tokens — credits are still noticeably more expensive than the subscription bundle.

And if you count the Codex unit in the $200 subscription as a half or a quarter of the total subscription cost — then credits become simply astronomically expensive compared to the subscription body.

However, a couple of years ago Altman said an agent should cost a small business the same as one employee at 2–3 thousand dollars a month, while doing far more than an employee would for that money. Ideally doing absolutely everything =)

I think that's where they're heading, both to “doing absolutely everything” and to “2–3 thousand dollars” =)

I wonder — if you code with an API token, does it come out the same? Coding by token on frontier models seems even more expensive? Though my latest data is from March '25, when two fucking mugs from the Escalator staff guzzled 20 thousand dollars in a month with Opus.

In general, as someone rightly noted recently in the discussion group, coding has rapidly moved from “you get paid for it” to “you pay for it” =)))

But guys, that's not because someone is trying to fuck over coders, it's because it's not coders who code now. And before, these “non-coders” paid coders fuck knows how many hundreds of times more for development than they pay OpenAI, if you count the output per invested dollar =)

There's a lot more you could reason about here, of course. In particular, that everyone who busted their ass vibe-wanking like me from September to March got a wonderful opportunity to learn practically for free.

From here on it will all get more and more expensive every quarter)

It can't be otherwise, unless of course Sam Altman invents a new economy and sells it to all of civilization, which I very much doubt :D

This kind of shit happens regularly when you work with the file system.

But I understood why. An order of magnitude less context gets spent. It writes code for a while and the context flies away, but then when the file-system debugging starts, all those tests with launches, installations of all kinds of junk, restarts, builds-fuckbuilds, all of that consumes extremely little context. Context is measured not in gigabytes of files but in thousands of characters. And to check a status and send a terminal command takes a piddling number of characters.

And OpenAI apparently lets Codex do whatever its heart desires on low-token tasks. In those 2 hours 20 minutes, no joke, ~250k tokens were burned. Of which 200k in the first 25 minutes or so)

In short, folks, as usual I'm getting fundamentally new experience through a game. Back in December I built chess, and thanks to that I learned interfaces, dynamic elements, traffic and much more, which I then wonderfully applied in my SalesBomb automation machine of 230 thousand lines (including tests and failsafes, as of today).

And now I'm doing something completely new for me — working not with the web over HTTP, but with a distribution, file libraries, a client being rewritten completely from scratch for my task.

So — it's fucking mesmerizing to watch Codex juggle files, test servers, builds. Every now and then new versions of the client open, Codex measures something, runs around a bit, clicks buttons in the game, hums disapprovingly, kills the process, goes and rewrites something, recompiles, assembles a new build, tests again. This goes on for hours. It works with a live file system significantly longer than with web services, and it runs simply a fuckton of tests that brought my computer to life. Some coder gizmos get installed, some programs restart, and a completely different reasoning monologue in the chat. It really digs around like a detective, openly rejoices at progress, gets upset that it crashed again…

Ferocious bliss)))

Okay, so who among us here are the Ultima connoisseurs and fans? Please throw into the chat, from your memories, what seems important to you and what you'd really miss. The more the better.

Between other things I've already built a lot; the server launch is very soon. I'm not going to fucking polish it forever before launch, because afterwards we'll just polish it together based on your feedback.

The main thing I'm finishing now is my own hand-written Inject, which is simply built into the client and will allow any automations. Frankly, I'm even considering letting you just paste in a model's token and let it control the game with no automations at all =)

In that case you could say “Yo, can you please max out all my skills? By any means; if you're missing something to be more efficient — get it by doing the necessary intermediate actions.” Or “Run around Moonglow and beat the shit out of someone; if they get you, try to run away, and if that doesn't work I'll wipe you the fuck out.”

But I think that would be worse than scripting, because Ultima isn't just actions, it's also reaction speed to what's happening, and a script will probably pull a reaction out of the model in any case =)

Although tasks like “log into my Plevel 7 account and dress all the NPCs in the game in thoughtful, beautiful outfits, much richer than default, with colors matching the spirit of each city, etc. — come up with the accessories and all that shit yourself” — the LLM does simply magnificently :D

Guys, imagine — I, dumb fuck, hadn't noticed that GPT has a GitHub connector.

And I noticed it because I'd started missing GPT 5.2 PRO, which so nicely helped me think through the deep architecture of important pieces of the system, where Codex itself seemed to lack the time OpenAI lets it think.

I'd usually throw an archive of the project into 5.2 PRO, wait an hour, and get a very well-thought-out prompt for Codex, much stronger than what plan mode in Codex can do.

However, when my repo outgrew 50k lines of code, GPT 5.2 PRO started throwing an error on an archive context of that size, and I realized that from there on Codex and I were left alone, and Pro could no longer help us at the global level.

Right now my repo has about 155 thousand lines, and I decided to try whether anything had changed in 5.4 PRO, and O MIRACLE: 5.4 PRO happily swallowed the archive and fucking brilliantly reviewed my entire 155-thousand-line project, not counting tests!!!

And then I saw the Git connector and got really happy.

I set up the connector, dropped a prompt without an archive, and it turned out that Pro loses the connector before it starts reasoning, can't find my private repo, tries to search for it on the Internet and doesn't see it because it's Private.

I was upset, but for the sake of experiment asked 5.3 instant to look at the repo through the connector… and it saw it. The connector didn't drop.

Then I asked 5.4 thinking.

It also saw the connector and my private repo.

Went back to PRO, and this whorish piece of shit once again doesn't see my repo, fuck!!!!!!!!!!!!!

So the most useful model is the only one that drops my GitHub connector and can't reason over the repo for me.

Meanwhile it reasons over a zip archive of the repo just fine.

Is this a known bug? Is it a fucking awesome paid feature? What the fuck is this, does anyone understand?

Dropping a zip isn't God knows what kind of problem, but it's strange.

And the problem with the zip is that if you then throw a second prompt into the same window with a modified repo, it kills Pro's brain, since it sees both zips at once with different content and gets lost guessing which one is correct, and starts producing bullshit. Restricting the reading to the second file only is useless; the first one still gets captured in the context, checked twice.

Halp

I want to record this strange moment here. Someday I'll want to reread how this becoming-a-vibe-wanker happened, and it'll be nice to remember that on March 13, 2026, I sank to the point where in ~28 hours from the moment my tokens were reset I burned through more than 50% of the weekly limit on the PRO subscription for GPT 5.4 — even though I don't use the speed boost that eats 2x, and I set the model's context to 500k, where the first 275k go without doubling, and I have to admit I don't very often exceed 275k in a single task, and I very rarely run two tasks on one context.

Not long ago it seemed to me that burning through the Pro plan by hand was simply impossible. It also seemed to me that developing a project would never need more than one file, and 8k lines was a lot.

After the latest refactor I reduced the number of files in ONE OF FOUR REPOS to 437 from about 548, and there's less code there. Only 200 thousand lines versus 350k, not counting tests (1,300 of them in 128 files)..

Curious what comes next =)

In short, I have no time for anything right now except what I've been laboring on for fuck knows how many days now… 60?

But the brain wants at least some entertainment, at least in a neighboring development branch; it's not made of iron.

So in parallel I'm tinkering with my Ultima Online server. It's been Up And Running for a week, but I'm dressing it up with scripts that will make the game on this server special and unforgettable:)

The plus of Ultima is that you can play it by playing, or play it without playing (automations, leveling characters = something happens, there's progress, and you just see it out of the corner of your eye and feel happy).

Usually all shard owners consider automation cheating and fight it. They also believe that a shard's atmosphere and gameplay consist not of possibilities but of restrictions.

Like, let's make it so fucking nothing is allowed. Let's make it so your stats are only enough to die in the forest to a bear. Let's make it so people don't have fucking enough for anything at all — that'll make the game so much more fun for them! Let's forbid them to mine ore automatically. Let's forbid them to hunt or do quests automatically. And if even after that one of these motherfuckers succeeds, let's wipe the fucking server))))

I'm not that kind of guy, of course. I want to build an Ultima shard designed for a world where vibe-coding exists and people have jobs and businesses =)

I want to make leveling hard to automate and, correspondingly, practically impossible to play by hand.

All restrictions can go fuck themselves. Any character can be maxed out in every skill. Crafting is built so that if you don't automate resource gathering and defense against monsters and other players along the way — nobody fucking needs you on this shard, go play on Outlands, they'll humiliate you there before you even register, and then every minute after)

I want to make not the game hard, but the world around it, which you'll still have to manage to cope with despite all of modern AI playing on your side;)

And the AI there will have to play not only for us but against us. I want to build an AI for the dragons and other beasts such that dealing with them is, to put it mildly, not easy =)

Raid bosses will have to be raided by hand, simply because I can hardly imagine an automation that could cope with the mechanics I've dreamed up. It'll take true fucking lunacy, and for that you go to humans :D

And of course it'll run on a MacBook, on mobile, in the browser, not just on Windows like all the wretched shards made by tram-depot administrators for tax-office clerks.

And for donations you'll be able to buy whole cities if you like =)))

Skill boosts, weapons of unheard-of power, etc. I never understood the point of no-donations or cosmetics-only shards.

If I want to buy myself a meteorite club for a grand and go around beating the shit out of everyone with it — why not?!?!!??!??!!?!?!??!? None of those admins was ever able to answer that question for me. They only came up with NO, but didn't bother to come up with a WHY for each NO. That's hard, after all)

Max Outreachtodayevich, a coder from birth, unexpectedly paid me a nice little compliment. We were poking at his API, and when I told him I'm a dumb cocksucker who can't get a certain list of features to fail-proof working order in two days, he let slip the phrase “Tim, you fucking underestimate yourself.”

Then he told me about the hundred interviews he'd conducted recently. They were looking for a couple of coders, but Max fully shares my worldview on the transformation of everything, and he needed coders who were exclusively AI-positive/native. In short, vibe-wankers far more than coders.

He conducted a HUNDRED interviews, and it was a select hundred — he'd pre-screened many of them with tricky little questions.

And they couldn't hire anyone))

And the biggest idiocy is that he interviews a guy who, apparently with GPT's help, described what a fucking great vibe-wanker he is, and tells him, okay, share your screen, show me what your setup looks like, how and what and why you prompt, and so on. In the end most people in March 2026 show that they can't really vibe-wank for shit.

Think about it: he asked a number of people to run a command in the terminal that showed the Cursor install date — 8 hours ago =)))) He did this when it was obvious the guy was on such formal terms with the interface of what he calls his main work machine that it was simply interesting to expose the degree of hidden bullshitting.

One guy, when Max caught him red-handed, just burst into tears like a little girl. He said it was all unfair, and he didn't want to retrain, he wanted the world to go back to when you could calmly bang out three scripts and get a big salary for fuck all.

What I'd say to such a guy in Max's place I don't even know. I think I'd just press the red button. Not because I'm so fucking heartless, but because that dumbass is fucking heartless. I already work like a beast, pay everyone around me money, spin like a hamster in a wheel, and now some lazy little bitch is going to flap air in front of me, squeezing time, dough, emotional support and energy out of me by every means, giving fuck all back in return. Sit your ass the fuck down and learn, it's even FREE, why the fuck are you messing with people's heads, you pissant :)))))))

There are people who just get it)

Once a week Maxim advises something that, out of nowhere, makes me start producing better-quality vibe-coding.

No wonder half the city fights over him when he decides to change jobs.

One time Maxim helped protect a huge TV star from an attempt on her life by her boyfriend, by hacking his computer) Imagine your surprise if you're a motherfucker trying to poison someone, and instead you end up behind bars because somebody hacked your computer? That guy's mom definitely wasn't lying when she said he was one of a kind)

I really hope I can get back to the Interviews soon, and Maxim will drop by and tell the story :D

Meanwhile, enjoy his tips along with me.

Fucking hell… You could really do that? With the right skills and libraries an LLM produces quality better than most design elements of the most expensive websites.

I'm sure most people make this mistake and beg their Claudes and Codexes in words to draw “something more fucking awesome,” and get a pixelated dick in profile.

Treat your model to a good LIBRARY. A well-fed model — a beautiful design!

And in general, for any technology, if you need to somehow extend the basic set of functions, google “awesome” + the name of the library or technology, and almost always you'll find a huge repository of curated solutions

Separately, I have to compliment the leap in design. And it's not only UI, it's product design too. I think these things come as a package — you can't understand better, at the level of reasoning, how to arrange the pixels if you don't understand, at the level of reasoning, what those pixels do, for whom and why.

As some have gathered, I built my own agency management system, which includes a fully proprietary Instantly, developed by me from top to bottom, and a dozen other systems, big and small. All the DocuSigns, Intuits and other stuff a business needs.

The huge plus of reproducing all these things under your own hood is their native connectedness with each other and with the core of the business. It's one thing to link these systems via API, and quite another when they're linked by one codebase and one database from the start;)

So: the screenshot shows an elementary, typical mechanism for adding CSV files, which get parsed correctly and turned into a campaign's mailing list. That's what the system will hurl emails by.

Previously I had it built so you pick a CSV file on disk, and off it goes.

I asked 5.4 xhigh to study everything related to CSV and think creatively about edge cases — does our system's design support them.

As a result 5.4 made me raise first one eyebrow, then the other.

It figured out things that not every human thinks of, judging by every interface I know of that I paid money for over the years:

1) Maybe someday we'll want to find the original source on disk, and we'd better know what that file is called, so we can search by the original name

2) Files are uploaded one at a time, but that's inconvenient. Why not just drag-and-drop the whole batch of any size and queue them for processing, with the option not to wait for the results of that processing — everything further happens by itself server-side.

3) A notification lands in Telegram with data on how many contacts were loaded, how many were deduplicated, how many days' worth of contacts the campaign now has.

4) Every interactive element has an icon; hover over it and a whole article pops up describing exactly what will happen if you click, and what results to expect.

And it all looks such that I can't find fault with it. The processing itself is animated too — looks like, I dunno, something out of a game — it's clear what's happening, every step of progress is visually emphasized.

Hardcore stuff, imho;)

Another big jump forward. Reminder: it's been 3 weeks since the last jump)

You're about to argue about the wrong thing because of one big omission

No “several teams” are going to take part in development =)

Teams, and coders in general, are now for scaling — when everything has already worked out and you need to move onto new rails

Until, say, a million in revenue, people will build their shit without coders, and they won't have any problems with microservices etc.

My most recent conversation about this was three days ago

I was complaining to a buddy about how fucking sick I am of coding

And that I can't get around to other important tasks

He immediately, reflexively, offered to assign me one of his developers

Who happens to love vibe-coding, everything just as I need

I showed him what I'm working on

And together we came to the conclusion that it would take me longer to explain to the developer what I need and why

Than to do it myself…

A vicious circle)

But I personally know exactly how it gets broken — people will do it themselves

Anyone who does anything at all himself on Codex will from then on do everything only himself

There's no point spending hours, and sometimes even days a week, explaining your feelings, thoughts and emotions in clumsy freestyle to another dim-witted human

In a day I produce more micro-features and progress than I'm capable of even putting down on paper

Let alone formulating it and making sure I'm understood correctly

In short, there's no longer any point at all in having coders implement things; a law of physics simply changed

This beer no longer falls down when you let go of it

In terms of interaction, people are no fucking different at all from an LLM, and an LLM that isn't trying at all)

To feel this right now, talk to some deep experts in their domain who long ago forgot that someone might not have a PhD in their subject. They sincerely believe they knew it all from the cradle, and everyone else isn't worthy of that knowledge.

For the full effect you need to talk to them precisely about their domain. Some narrowly specialized coder-founders are perfect for this.

Talking to such a person, you have to think hard about how to phrase the question so that he can answer it even somewhat intelligibly. It takes 10 or more attempts at the apparatus) With each attempt the risk of silence in reply increases.

No wonder Steve Wozniaks need Steve Jobses, so that their business team has more than two autists and more clients than a couple of childhood friends who did well =)

Lately I talk a lot with people who, before my recent leap in development smarts, wouldn't have talked to me at all.

God, how hard it is to make them simply answer some important question directly and completely. From some of them I'm trying to buy something, but it's incredibly hard to do, because they can't open their mouths and tell me in detail how their shit specifically performs its function, and without that there's no point in buying — a vicious circle.

And that's me entertaining them as best I can, while an ordinary client wants to BE entertained) And even if he's entertained long and thoroughly enough, he'll still think about whether to transfer the money.

I have no doubt that even with fucking awesome vibe-coding, in a scalable product business I need a technical co-founder. Not only because without him you can't scale load quickly, but because there's no time to deal with technology if sales are flying — you have to fundraise and fuck around all over the world on a business mission, which pairs like shit with silent staring into a terminal.

However, in my memory the absolute majority of technical founders avoid sales/marketing/business co-founders in every way. Most likely out of disrespect.

So they sit on their technically perfect projects with 100 unique visitors a month on the site (95 of which are crawler bots), and jerk off over forks and stars on GitHub, which don't bring in a fucking cent of commission)

I understand that I've pissed off some people really fucking badly with my notes about vibe-wanking.

But, first, this is a channel about vibe-wanking.

Second, rather than sulk, let's make out instead!!!

So. This agonizing 24-hour development of mine is pushed forward not only by curiosity but also by a peculiar philosophical vision of the situation taking shape.

If the world throws people like you into the furnace, the most reliable way to come through it with dignity is to arrange a training for yourself in advance, as similar as possible to what the world will later test you on.

Your own trials are easier to pass: you set the rules yourself and understand what it's all for. They sound concrete — unlike the murky test program that the world hasn't even properly formulated yet.

My personally set trial for this year: I no longer do anything by hand that I can achieve through automation within a sane timeframe. And that is everything that repeats more than X times. I haven't settled on the size of that X yet, but it's unlikely to be much bigger than ten. So: if I intend to, or will be forced to, do anything not related to pleasure more than 10 times, then I must automate it once, whatever it takes, or not do it at all.

At the current stage this approach to life doesn't yet feel very comfortable, because although AI is developing fucking fast, it's still in deep beta.

Some things I could do by hand in five minutes, but coding their recurring implementation sometimes takes me 2 or even 4 days, and sometimes all of 10.

During those days I irritate people, lose some options, harm the processes of the moment.

However, if you work it out on a calculator, the damage from the lifestyle chosen for this year is far smaller than it seems, and the real upside can't be measured with any ruler.

Arithmetically it's tempting to think that 2, 4 and 10 days consist of a fairly small number of “five-minute slots.” There are a full 288 five-minute slots in one day. Think how much you can do! Okay, you also have to sleep, which leaves us 192 five-minute slots.

But an experienced user of life knows that 5 minutes of any work is never 5 minutes. It's 5 minutes of the task + double or triple kickback in the form of procrastination + energy lost switching between tasks + the slippage of reloading mental context + the resistance of entering flow if the task requires creativity.

Sometimes 5 minutes of work is 10 physical minutes.

And sometimes it's several hours, or even a whole day.

I'm sure everyone understands perfectly what I'm talking about and can recall recent tasks that “seemed like fuck all to do,” yet for some reason took an entire day.

There are “5-minute” tasks with extremely high viscosity: they stick like shit to your feet. Invoices without data, email replacements without context, reconciling something against something, clarifications with elements of a game of telephone, “take a quick look and tell me in two words” — none of these are tasks, they're slime. It's easy to drown in them because they have no clear boundaries. A true slacker simply dies from each such task and rises again only tomorrow.

There are “5-minute” tasks that expose 100 other tasks that also need to be done in 5 minutes each, because without them the original one makes no sense.

Recently I was in the shower — and, languidly soaping the inside of my thigh, I realized what the main change on the map of society is right now. Something I'd started to feel back in '22 but couldn't quite catch.

Society is reaching escape velocity in the race for time.

Time has always been a relative parameter. Relative in many senses.

Relative to one event it drags, relative to another it flies.

Some people think thousands of times faster than others, yet live a biological span of comparable length. Does that mean one person lives a thousand times more life? Of course.

Two minutes in a plank is a small eternity. Two hours in a game where you're “one more match and then bed” is a small instant. Time expands where pain torments you and contracts where dopamine is being injected into the blood.

There is “clock time” and there is “attention time.” You can live eighty years with the light switched off inside, and then it will be a short life. Or you can live thirty, but with attention to reality so sharp that it's longer than several centuries.

The time of a person who knows how to say “no” is longer. Because he doesn't scatter his life on other people's wants. He literally buys his hours back by cutting off the costs expressed in time.

Interest and compound interest are the mathematics of time's relativity in money. A year for capital that grows is longer than a year for capital that sits. Same calendar, but a completely different physics of expected value (that is, a different trajectory of the future under the same calendar).

Time in relationships is relative too: one minute of silence after the phrase “I don't give a fuck” can drag on like the funeral of a one-night stand. And three hours of honest conversation can close years of internal drama.

And so fucking on…

So: the race for time has always existed. And it has been quite democratic — that is, bloody and cruel =)

When parents send a child to Harvard for insane money, they're buying a chance: for the child to gain additional relative life-time within the same biological span. Not hours on a dial, but time-as-opportunity: fewer dead ends, more doors, a higher growth rate.

One person starts from zero, another from ten million dollars. The first can grow, fight, get smarter, accelerate, but the statistics are cynical: in one lifetime he most often doesn't even reach the second one's starting line. And it isn't about “talent,” it's that their time has different purchasing power from the outset.

Life isn't only money, I know. But to give the system a shape you need convenient viewing angles. Cash is convenient because it's numbers everyone understands. All the other forms of this system you can construct yourself: a metric can be found for any emotion, but to do that effectively you need to be a lot more than what it takes to just feel the difference between “$0” and “$10,000,000.”

So here it is: the distance between people is now going to start growing at a fucking insane pace.

The Internet gave everyone equal access to knowledge, but didn't give equal access to discipline, attention and the ability to assemble knowledge into value, which significantly aggravated the inequality of time. AI will give many people access to acceleration, but won't give equal access to choosing the right goals. And that is a completely different sort of inequality. And even when access seems “equal,” the context isn't: one person has 2 hours a day and chaos in his head, another has a team, data and iron discipline.

AI will now amplify what the Internet started by an unthinkable factor.

The gap between people grows not because “some are smarter.” But because some learn to convert effort into a system on the fly, while others keep converting effort into fatigue.

People learning to vibe-code today aren't learning to write code — it's no longer the center of the digital universe. It was needed only so that the digital universe could be born at all out of a gas cloud of poorly combed zeros and ones. That is, code was the language of the primary assembly of infrastructure. Now the infrastructure is standing, and value is shifting five parsecs over — to setting tasks, designing processes and controlling quality.

Code is no longer the main skill, because code is the “how.” And the world is starting to pay for the “what” and the “why.” If you can formulate a task, bound it, check its reality, calculate the cost of an error — you're a god of the new world. You're the one who'll now kick open the bar door and order beer for everyone. If you can't — you're just a passenger in someone else's product. And you're the one paying for it, as a passenger, not being paid as before. Before, you were a piece of the driver, the fuel he ran on, expressed in the time available to you that he bought from you. Now your time is needed only by you, and only you will be able to convert it into benefits for yourself.

It's important to realize that those who are vibe-coding flat out right now are learning to live in this new world: where you don't “type characters,” you assemble a conveyor. You don't write code — you set up machines that stamp out results: emails, reports, invoices, deals, research, applied use of that research, content, products. Assemble it once — then it runs by itself and doesn't crap on your soul every Monday. You know EXACTLY what will happen in a week. If that stops satisfying you — you improve the system, and again you know EXACTLY what will happen in a week.

The especially talented will invent not “pieces of matter” but new tools and protocols: how people buy, how they learn, how they work, how they make decisions. That is, they'll reflash consumers' daily lives, offering better solutions than the consumer himself could come up with — who, if he could come up with something better, would have created it in the same place you did, for pennies.

The mass of people who in all seriousness are now “learning to code” with the help of vibe-coding, instead of learning to solve any of their own problems with automation, are the monkeys from the fable “The Monkey and the Spectacles.”

I remember how in childhood every neighborhood dumbfuck, including those who couldn't string two words together, knew how to replace the thermal paste on a CPU to keep playing Duke Nukem over a cable (there was no Internet yet).

Now many of those dumbfucks earn 30 thousand rubles as warehouse loaders — and keep replaying Diablo 2.

Many born after, say, 2005 have never laid eyes on that fucking thermal paste. And it doesn't stop them from looting $150k+ a year working as engineers at the best companies on the planet.

Writing code is smearing thermal paste on a processor.

Vibe-coding isn't coding instead of coders, it's everything except writing code.

It's the skill of designing interfaces. The skill of working with load. The skill of budgeting the start, the middle and the finish. The skill of scaling. The skill of switching, refusing, connecting and disconnecting.

WANTING AND CHOOSING.

You can list this shit forever, and this shit isn't such shit. It's gold you have to manage to mine. It doesn't jump into your head by itself, and there's no fast track here.

It's the skill of breaking your own head and ceasing to think in actions, starting to think in systems. It used to be “Idea -> Effort -> Result.” Now only “Idea -> Conveyor -> Result” will be valued.

I once devoured those fucking BOOKS on the same principle. I doubt I liked every book I read. Read Freud — you want to cry. Read Nietzsche — you go mad. What the fuck is pleasant about that? But I had to break my poor provincial head and force an enormous mass of meanings into it, to be figured out later. And every one of them came in handy.

I looked at rich and famous people, and listening to their speech, looking at the products of their lives, it was crystal clear: without the puzzle pieces you can't assemble the expensive puzzle. Only the cheap one with six micro-pieces from a Kinder Surprise, and even then only if there's a Kinder Surprise, and if it contains a puzzle and not some fucking Mickey Mouse.

Every automation, first, lets a person get smarter by that automation and then reproduce the needed pieces for the next task ten (and later a hundred) times faster. It's like learning not the answer but the way to obtain answers.

Second, it simply speeds things up. Because today I stop spending 5 minutes which, as it turned out, are never 5 minutes. And tomorrow I'll stop spending 50, which aren't 50 at all.

I think that starting tomorrow I'll begin to live a life several times longer than those who also try but lag behind. And billions of times longer than those who keep lowing at the caravan and poking a hoe at a rock.

This race isn't just announced, it's already underway. Participating isn't mandatory, but it's better to remember that the economy is a very sturdy condom.

90% of the condom gets grabbed with their greedy mitts by the top 1% of the world's racers while nobody's watching, and they fuck off into the sunset in the most souped-up cars. And the thickness of the remaining 10% of the rubber, how it thins as the leaders pull away from the chasers, and which side the rubber thins on — I don't think that needs explaining even to first-graders.

Only now a souped-up car can be assembled practically for free. You'll have to pay only with a heap of discomfort, patience, time and blood, but everyone has those resources.

Right now AI will add x10 to every racer who wants it. Tomorrow x100. The day after, x10,000 speed.

Which side of the condom you want to ride on, thick or thin — that's up to you.

But the mechanics these days are simple: either you build conveyors, or you go fuck yourself:)

Yeah, I dream of going back to Dota

I just promised myself I won't play until I finish a few things

And I've already done almost everything on the time-consuming list

Just today I was thinking that any day now I'll be able to sit down and fucking play

Today I still can't, because I haven't finished what I have to

I just fucking got carried away in the end with automation at the agency

Today, for example, I finally finished this flow

1) I now have a fully custom Telegram CRM with a UI

Some of it manual, some of it pulled in, for example, from the requests on the website. The CRM pings me so that I ping clients, and offers me the results of micro-deep-researches and several ping options to choose from.

2) When I kick a lead over to “contract signed,” the lead drops into the “Clients” section. There the signed contract is automatically scanned, all the billing info is filled in + the first invoice is automatically issued and sent to the invoice storage and to me in Telegram.

3) All the documents for each client are stored and checked for the correct numbering format, de-conflicted

4) When a new client is created, workspaces in Instantly, domains, mailboxes and other accounts get created — automatically where possible, manually otherwise (the system pings me so I don't forget and won't let me press the “Done” button until everything is done).

5) When I press “done,” checks and tests run to confirm that everything about the client is known correctly and pings/works. Every webhook, every workspace.

6) The infrastructure automatically goes into warm-up and reports the warm-up status to me every day.

7) When 7 days of the paid period remain, an invoice flies out to the client from the bot. Another bot tracks incoming payments by the Company name from the billing details on the invoices, and if no payment came in — every day the bot nags the fuck out of the client to transfer the money and share the payment confirmation.

Honestly I can't be bothered to describe it all, but there are dozens more elements. Smart rotation of mailboxes and checking them for spam health (I ended up building my own because it actually works, unlike that paid snake pit which only exposes your mailboxes to Google as a fucking spammer because you use such services)

Even fucking contacts are semi-automated. Not fully, but for launching test hypotheses, chunks of contacts by particularly obvious criteria aren't hard to mine and sort onto shelves automatically

Thanks, will study it

Well, I've finished vibe-coding our analytics system.

It can now pull literally all the data out of Instantly and perform analytical miracles with it, sending it when it's needed to where it's needed. All that's left is to bolt on invoice mechanics that will automatically invoice clients and automatically track payment on those invoices, plus some LLAMA to reason for free over trickier queries to the database than what's hard-wired — the ultra-weird rare “think about this” requests that are just dumb to turn into a hard-coded lever.

The whole thing took about 40 hours of vibe-wanking.

Over these couple of projects that work not for fun but for real business (money moves = business is real), I understood not just in theory but felt in every cell of my body how pointless it is these days to start anything in the SaaS category.

Even over these couple of months of vibe-wanking, everything has jumped a hundred miles ahead, and today coding without skills is several times easier than it was two months ago. The models simply can do more, think smarter, err less often, lay down more padding, and demand less pedantry in how you word the request.

As before, I maintain that somewhere during 2026 code will write itself. Nobody will give a fuck about its quality, because these are projects “for yourself,” not for others. For an entrepreneur building for himself, the main thing is that the button clicks. For some tasks it's enough that it “at least sometimes clicks on the third try.”

The future belongs to business models that can actually do something in the physical world. The digital world is being taken away from entrepreneurs for good. Today there are still these arguments about whether it will keep getting smarter or not. But it will, and then even the ultra-complex projects you can't vibe-code today will lose their main property — the multiple-based valuation. And as the practice of ordinary startups from the year before last shows, losing valuation for a startup is like losing blood for an organism. Such an object flies out of the venture scheme and the wolves tear it apart. It still lives for a while, of course, but that's not life, it's meaningless existence.

Seems I'm a bit slow((

For some reason it didn't occur to me right away that Codex could be used like this:

1) Hey Codex, whip up a new project in the parent folder please, call it slsbmb-legal-finance

2) Hey Codex, go through all the PDF files in the downloads folder, find all the invoices that organizations X, Y, Z, K sent to their clients (any companies), and copy them into the root of the slsbmb-legal-finance project, split by year please.

(It fucking churned out a script that did this task across 2,800 invoices on the first try without a hitch!!!!)

3) Hey Codex, name all the invoices so they're mega easy to navigate: sequence number by date in ascending order (one digit, 1, 2, 3, etc.) — client name — month

4) Here are read-only keys for the banks; please cross-match which invoices ended up receiving money and which didn't. Be attentive to detail and don't mix things up. Look at references, dates, amounts if you need to; if some files are unclear, try to make an assumption; if you're not sure about the assumption, flag those files somehow and note it in the report — I'll double-check myself.

That way, in 20 minutes I got a folder with all the invoices of all the companies I run, with confidence that these are only the genuinely useful invoices (people who issue invoices know that the process produces a lot of junk, re-issued invoices with different properties, etc., and sorting that out by hand in a folder of 2,600 files is fucking hell, easier to shoot yourself).

And now I can just cd "project" and drop requests like “Slap out the next fucking invoice for Airvoice, check the numbers on all the invoices so the next one is definitely numbered right. The properties don't change (or if they do — you can just freestyle a note about what changed).

Or….

Here's a contract, please make an invoice from it for the HK company with the same properties as the other invoices, take all the details from the neighboring invoice, the last one issued for the HK company.

Or….

Please check, are all the invoices paid? The bank tokens are in a text file in the project folder.

The simplicity of this interaction is beyond comprehension, relative to its usefulness.

People sit and vibe-code themselves invoice management systems, with interfaces of some kind, but what the fuck are they needed for?

That's it, we're in the new Internet, where interfaces aren't needed, you just have to actually think your way to the simplest solution, and it sort of does itself =)))))

Well, I just did all of this, and it didn't make a mistake =)

I'm especially fucking floored that in 9 minutes it whipped up the scripts that helped it deal with 2,600 files and find exactly the ones it needed

By the way, I doubt the previous generation would have handled this task; I think only the very newest, just-released ones have learned to do this

Dunno, the only thing I can suppose is one of two things:

1) I didn't sit there for 5 hours, but 100+, before anything seriously moved off the dead center for me.

2) Because of your professional deformation you can close your eyes to the limitations, while I, on the contrary, look for them in order to use them, since they are the only channel I have.

For example: you know exactly how the cropper task should be done, and the LLM can't do it that (correct) way.

So you get indignant and think the LLM is dumb.

Whereas someone like me, who has no idea how such a task should be done, will end up poking at it this way and that, and will notice that cropping the photo along one line works pretty reliably, and the problem is with the remaining three lines.

So I'll just fucking slap together a kludgy script that cuts four times along one line, and enjoy a working cropper, while you sit and wait for it to start coding for you the way you know how.)

Maybe a bad example, but I know it's true to life, because I see it in my buddies — deep coders who don't use LLM coding because looking at clumsy-ish code drives them nuts.)

And the fact that this code is free, unlike beautiful code — unfortunately only entrepreneurs understand the value of that phrase, and not all of them, mostly those who can't code themselves or haven't wanted to for too long, or older people who have long been fucking sick of everything in principle, and to whom any automation is by default perceived as fucking awesome.)

There's an opinion that vibe-coding and coding are fundamentally different things. And one gets in the way of the other very, very badly =)

Also, vibe-wanking needs ferocious stamina, because unlike a coder's stamina, where a person knows in principle what has to be done and it's just tedious, in vibe-coding the person doesn't know what has to be done and doesn't even know whether it will work, or whether it's even possible. So you really have to sit there and bang your head against the wall =)

For example, I don't even expect many of my acquaintances to vibe-code anything until some AGI shows up that does everything for them from a single prompt, because they don't have enthusiasm for more than 40 minutes even on clear tasks. Accordingly, the only processes that work for them are ones whose result fits in a 40-minute window. Hanging other processes on them is pointless — it'll just be a death loop.

If I have 40 minutes for vibe-coding, I won't even open Cursor. The minimum useful outcome in a day takes 3–5 hours to reach; whether it's 3 or 5 depends on luck :D

Also funny that when I was working on the bot, many people asked, like, fuck, why the fuck are you spending your precious time so inefficiently? You've sunk more into this bot than it would cost to pay a coder…

Many people greatly overestimate the usefulness of an entrepreneur's average working hour =)

Entrepreneurship is essentially the same vibe-coding, only across all of surrounding reality. Sometimes to earn $10k of NEW BUSINESS you need to spend 20 hours, sometimes 2 hours, sometimes 200 hours, and sometimes 1,000 hours. (Old business generates itself, it needs an order of magnitude less time, because under that cash flow everything is already delegated, automated, optimized; the entrepreneur fights precisely for new business if things are more or less fine and the business isn't collapsing.)

What I build with my own hands without having to spend time and money on people, while also pumping up extremely valuable skills — that alone is fucking awesome, and I'm not building just anything, I'm building precisely what makes every further invested hour increase profit in one form or another. Put 100 hours into something that then saves even 10 out of every following 100 hours — that's pure ROI pouring into your pocket after just 1,000 hours. 1,000 working hours is only one quarter, so in 4 months my lousy 100 hours start paying me back, for years. And these are all just example numbers. Reality is far tastier ;)

Bro, forget what the guys on the Internet say. A thought, once spoken, is a lie =)

The real players don't say anything to anyone anywhere on this topic — that's the solution to this thrilling riddle.)

I know a guy who single-handedly built an entire EMPIRE on plugins for Jira and Salesforce/HubSpot.

He simply hammered out 2 plugins a week.

Out of every 50 plugins, one took off to the point of bringing in about $1k a month.

And one plugin took off so hard it started bringing in $10k a month.

Sounds like bullshit, but over 5 years he got to the point where his plugins, with the long tail, brought in enough that he sold his business for $7 million.)

And before that, all that time, he was earning, let's say, not badly either — he was definitely clearing 50–70k a month.

Unfortunately he doesn't talk about it on YouTube =)

In B2B, to sell it's simply not enough to LISTEN TO OTHER PEOPLE'S TALES ABOUT PROBLEMS.

Until you've held a candle over the problems for many, many thousands of hours, you still won't understand them.

The trick isn't the problem itself, but what makes it a problem.

Very many B2B products, not understanding this important detail, rush to build something and flop.

Because the reason certain buttons don't get clicked turns out to be nothing like what they thought)) They thought people lacked the right buttons.

Turns out people are just fucking losers.

And that, alas, you can't vibe-code away.

Bingo. Most solutions that in the laboratory appear to perform a very useful function very well end up never being used by anyone except the lab assistants of that laboratory.

For anyone to use your shit you need to know not the problem, but everything inside the organization that frames the problem, gives birth to it, the economics of that problem across the most varied departments, and so on and so forth.

Take my genuinely successful acquaintances who live very well in B2B — they can explain their clients' business TO THE CLIENTS far better than THE CLIENTS understand it themselves =)

If you can't explain and sketch a logistics company's entire business on a napkin for them, there's no point trying to build them technical solutions.

A simple example:

We had a client who claimed his research showed that every construction company in America needed to reduce the rate of foot diseases (already funny) among workers on site, so he raised $500k for an app that scans your foot (actually just a GIF it fucking spits out, there wasn't even any technology) and shows how badly a worker's foot is developing, letting you preventively head off his foot, fuck, and back pain.

I'm thinking, well, fuck knows, but the guy says they did a study, everyone fucking desperately needs it.

We went to sell — nobody answers.

I went to acquaintances who are the second-largest construction company in California.

The owner of that construction company is straight-up my buddy.

He listened to me for literally 40 seconds.

And he goes, fuck, Tim, come on, for fuck's sake, you too, for crying out loud

You know, he says, what health problems my workers have?

They don't put on HARD HATS, FUCK, on super dangerous sites

And they get their FUCKING HEADS CRACKED OPEN

Healthy feet aren't going to help there, he says, you understand?

The guy, like, lived and lived and died, fuck

Right on my CONSTRUCTION SITE

COCKSUCKER

And you know what else, he says?

They don't clip in!

The dumb ape, he says, climbs up the boom to a height where birds freeze

And he says the dumb bitch forgot to clip in, and of course he smashed himself to fuck right at the moment he forgot — that's how it works

You, he says, fix THAT shit for me

And then, after another 15 problems that also need solving, more serious ones, maybe we'll get around to the nice healthy feet of these cocksuckers

But actually, he says, I'll tell you a little secret — we won't get there. I fuck in the mouth the ones with sore feet, you know what I do with them? I FIRE them

What the fuck, he says, do I need construction workers with sore feet? For every worker with healthy feet I've got 500 Mexicans standing in line who'd win an Olympic medal in running tomorrow if that's what it took to get the job

So, he says, take those startup fairy tales and shove them up the ass of whoever told them to you

And go do something useful =)

Talented biz-dev people are rare, but that's not the point. The point is that the claim “it's wrong to ask an LLM for X” or “wrong to expect Y from an LLM,” and that instead you should “hammer out code that correctly pulls the data format out of the right APIs and puts it where it belongs in the right shape” — that claim is exactly where the gap between engineers and everyone else has always grown from.

Except I never expect engineers to do my job even 1% as effectively, while they usually talk as if you're not a human being unless you can fucking knock out a little script that automates something =) They forget how many tens of thousands of hours went into their specialization, and that it started back in grade school, honestly (that's what the straight A's were for, and the math olympiads).

That is the whole global point of LLMs showing up. Automating anything by hand, with coders, was always possible — for money.

It's just that the money is paid by people who sometimes can't even articulate what they need (a gigantic inefficiency grows), and the same people usually can't check the result either (the gigantic inefficiency gets multiplied by a sack of dicks). So the world arrived at a place where, if you have no money, you can't afford to fucking run a business at all, because building something big, sweaty and permanent with coders' hands takes real billions. Something small and shitty but working — still millions. And where do you get those in a world where, by official numbers, over 25 YEARS a person in the UK on £80k (three times the average salary) saves somewhere between £900k and £1.4m?

OVER 25 YEARS

Which means that “on their own dime” a person can't afford anything development-related in the current economy, and going forward will be able to afford it with ever-decreasing probability.

And then the LLM arrives, which is supposed to make it so that any regular Joe can make his dream come true for a very specific, understandable amount of money.

An LLM is a kind of global standardization of everything. Putting in order, all at once, all the knowledge humanity has accumulated and the practical ways of using that knowledge.

Technically, as long as the question in this chat is “how do I enrich a spreadsheet with just a request” and the answer is “for now, you can't” = the LLM is a concept car that doesn't even have a proper engine in it yet, pre-pre-pre-alpha.

But you can see the bricks — the operators, contexts jumping into the millions, the fabulous growth in accuracy, and so on. It's all slowly converging from every side toward a single point where any regular Joe in this chat tells the LLM “I want this” and “gets the result.” The result may be better or worse, you can argue about prompting and so on. But for now you can't get the result at all without code.)