Inference is actually quite cheap for token costs, the frontier labs burn most of their money on training new models, priced into their token costs ontop of some margins and paying record salaries. So if this goes open, distills are tried out, independent providers around the world host it with actual price competition, the house of cards for anthropic collapses pre-ipo. The floor is opus (open models caught up), the current ceiling is Mythos (self inflicted ban due to the safety bullshit theater), and no way out.

It’s really comical I think it’s even the same guy that warned about gpt2 being too dangerous to release, well that mindset seems to now doing existential harm to anthropic, while the rest of the world essentially laughs and progresses anyway.

Andd boy, a REAL type system is just something i won't ever again compromise upon. I mean yeah I did many years of Ruby/Rails and loved it back then, and Elixir in that regards at least on surface felt strictly better (sweet pattern matching, pipes, ...) but just SO MUCH CODE is written either at runtime or in loads of tests that essentially make up for the lack of a compiler guarantee about type errors i cannot unsee it anymore. Rust is way better here for example for sure, Trait system and all, but here the compile time tax is very real even after fiddling with optimal crate splits. Plus _sometimes_ a bit of simple mutable code just hits home in a few lines instead of often slower pure FP equivalents.

Happy to see that Elixir finally after years in the making is arriving somewhere, but I essentially left the ecosystem now since I really do either TDD (Type driven Development) now or quick solutions with node/go when quality isn't the concern... and now I discover OCaml (with Effects based multicore now) and yes the syntax is _a bit_ alien but damn it checks all boxes of all techstacks I ever wanted. I can write nearly Elixir style code, pattern match pipes and all, I can write (nobody does but I could) failry powerful OOP stuff, compile instantly, in a statically linked binary, with true parallelism, and a type system that is amazing (don't get me started about module functors). Beam is a impressive feat of engineering, but its also moving like molasses and deployment is nontrivial and quite cumbersome to operate (at least people need quite a lot of learning curves until theyre comfortable with this powerful beast). And then there is OCaml. And the tradeoff here is on the human side, nearly no one knows it, learning curve is high, so statistically no team would pick it in most businesses or has experience with it, and that specific situation is personally for me irrelevant now as a solo builder in an LLM age.

Lets see how good this becomes at some point, I am watching and would have loved to have this at least gradual typing available years ago!

true fullstack (not only tech parts - from marketing to product to boring IT and financials) makers now have insane speedups, IF they previously did everything by hand properly and found ways to be good at it solo. Often the only scarce resource was your own time (or more correct: attention/focus hours per day) for execution and research. Now offloading stuff to agents, especially since you know the domain and the shortcomings by heart and when to (not) not trust AI is supercharged.

People fail to reap benefits for organizational scale and mostly fail completely, they try to make AI fit a human process spaghetti theater somehow, but a lone wolf can just change himself entirely in days and be adapted and leverage AI-first if he wants to. just like that. no coordination needed beyond rewriting personal scripts, which is fast with LLMs too.

so I COULD take over by hand again like I did the decades before just fine, but I refuse to and instead play a codebase like a RTS - lots of stuff happening in parallel but at all times a understanding where is which thing going on and have the next steps in mind (sometimes directly queued as follow up instructions). For me vibecoding is a strict speedboost and literally gamified projects I work on, and the guardrails not only in textfiles but much more in executable code (linters, tests, dependency checks, playwright, ...) as feedback loops agents can spin on on their own made it all click together to the point my main bottleneck is stuff like the Codex app itself using high CPU and memory on my local mac.

- crawl all relevant news sites and subreddits hourly, rss fetch style, and for every new thing let a small LLM think about what X means in essence and derive insight nuggets or thoughts about "what does this mean for customer group X", super fast and cheap oneliners essentially but at times surprisingly good snippets.

- add in designated slack channels and allow direct tagging of a bot so that internal discussions inputs also go into a database with a similar LLM treatment of extracting the interesting bits and pieces

- have a hourly cronjob look at the new stuff in those databases and create proper hypothesis/assumptions for customer behavior and needs, lean startup style, or link new stuff to existing stuff and refine it.

- have another hourly cronjob go through the new/changed hypothesis + some knowledge about our product/platform and formulate feature candidates worth building that are distinct and linked by evidence

- so far its all just code + LLM with some statistics for relevance, essentially a bayesian board of ranked experiments to try next, running fully on autopilot, and quality 80/20 is fully acceptable.

- I added a straightforward kano voting UI for internal folks on the most promising candidates to get explicit human judgements factored in, again some math formulas of weighing stuff changing the scoring significantly depending on vote results, and everyone can give their input/judgement in a asynchronous way, human touch decentralized, future planned as in-product little feedback ask widgets to get thecustomer voices in it, too

- I am the only one who can pick "the next thing to build" from the prepared and ranked list without much emotion but with my own judgement so I can also pick not just the highest ranking item but for good reason a different thing slightly lower. onclick github issue is created and framed with a user sotry and the hypothesis + all the context accumulated bottom up nicely formatted as markdown

- my codex/claude code on the platform repo knows how to work with GH issues and what the processis, so I pick up the next formulated ticket and brainstorm together HOW to build the hypothesis in a semi-supervised way (vibecoding, but with precise context and me driving it with my own judgement/ideas for how to make it happen in the best/leanest way that is faithful to the hypothesis)

- shipping it closes the issue, goes back to the feature candidate, moves it into a "measure" state, and then knows which metrics to observe, aka did the feature move the right needle and how much, and after a significant enough amount of time its clear it was good/bad/neutral and I can either do a cleanup or leave it there or report success, which then updates the underlying initial assumptions with strong real world evidence up or down, which naturally reorders the feature candidates list linked to the assumptions list, changing where to go next instantly

... essentially I built my own hamster wheel, reducing the "what to build next" into something that feels scientifically enough for people to trust it, with manual intervention through voting, and a stupid simple place to just drop any observations/ideas with slack without ANY special formatting or writing requirements and have it bubble up into concrete things to build autolinked with supporting/contradicting evidence from world news etc. The actual build/execution I do as you all then with guided vibecoding, reducing the cost of build to minutes/hours instead of days/weeks, with zero meetings needed, realtime and asynchronous.

... is this what you looked for? I streamlined product to become like 2 clicks from my end and zero product people needed beyond myself, and streamlined tech to vibecoding + grounded context, going into a kind of guided shipping loop with learning loops closing automatically along the way. and when AI takes it 30 minutes to flesh out a new thing its all the time freed up so I can talk ideas or feedback stuff with colleagues while the machinery is humming. Never been happier to be a devops/fullstack guy.

GPT 5.4+ takes its time and considers even edgecases unprovoked that in fact are correct and saves me subsequent error hunting turns and finally delivers. Plus no "this doesn't look like malware" or "actually wait" thinking loops for minutes over a oneliner script change.