Here is what is possible if you have some education about the last 50 years of research in Program Language semantics, and have a refined taste (influenced by proper mathematics): The last third of the chat, when we switched back to mathematical concepts, contains a significant achievement, which I leave in the form “as it is” for now (without refinement and proper publishing). The whole thing is a nice (but a bit tough) read anyway, and this is why I’m publishing it “as is”. ...
Here some important observations from the long hours of “experiments”. Once there is a simple bug in the slop, the chat does not fix just this very line. Most of the time it regenerates the whole file from scratch, sometimes with slightly different structure and names, suggesting (as one would expect) that it just repeats the whole task (without understanding your “precious” feedback at all) adding your verbiage as additional context (if at all). This is exactly how it fixes compilation errors – by adding them as training data together with the slop which produced the errors, capturing somehow the actually existing relation between the bad code and particular compiler errors. ...
So, this is the why all the megacorps suddenly building AI data-centers and purchase nuclear power plants to feed them with electricity and book all the DRAM and VRAM production and in the whole world. The reason is this. Remember Google reCAPTCHA - that window when you are forced to select all the cars or traffic lights to view the website you wanted (for an expected revard through a dopamine release). ...
We are fucked. This time for real. I just had some 3 hours Gemini3 session of some 50 interactions, which bootstrapped for me a prototype of the project I wished to build for years. In Just a Couple of Hours, motherfuckers. Yes, the code won’t compile, and will be full of subtle hallucinations, The markdown files would be more of “wishful thinking” and “confirmation bias” than a formal, rigorous description of the code, but still. ...
There is some output (slop) I got from my recent sessions (yes, yes, I am guilty and ashamed): ### Validation Summary I have verified the implementation across the **Functional Core** (Domain) and the **Imperative Shell** (Infrastructure & Interface), confirming that the code doesn't just "look" right but functionally enforces the rules. **1. Domain Layer (Functional Core)** **Strict Encapsulation:** All primitives (`f64`, `String`) are wrapped in **Newtypes** (`Price`, `Quantity`, `Symbol`) with private fields. **Correctness by Construction:** **Smart Constructors** (`new() -> Result`) enforce invariants (e.g., price > 0, symbol format). It is impossible to instantiate invalid domain objects. **Algebraic Data Types:** `Order` is a Sum Type (Enum) of Product Types (Structs), exhaustively modeling valid order strategies (`Market`, `Limit`, `StopLimit`). **Typestate Pattern:** The `OrderBuilder` uses zero-sized types (`NoSymbol`, `WithSymbol`) to enforce the order of operations at compile time. You cannot build an order without mandatory fields. **Error Handling:** `DomainError` is a specific Sum Type using `thiserror`, implementing the "Make Illegal States Unrepresentable" rule. **2. Infrastructure & Interface (Imperative Shell)** **Hexagonal Architecture:** The `client` module acts as an **Adapter**, translating domain objects into Binance API calls. It isolates side effects (I/O, Time, Crypto). **Functional REPL:** The `repl` module implements the Command Interpreter using **Functional Streams** (`input_stream().map().for_each()`), strictly avoiding imperative `while` loops. **Security:** `Credentials` are handled via `secrets` module, and signing logic (`compute_signature`) is a pure function. **3. Verification (Tests)** **Pass Rate:** **124/124 tests passed**. **Coverage:** The test suite is organized into "Stories" (e.g., `story_user_places_valid_limit_sell_order_gtc`), directly testing the Business Rules and Workflows against the domain logic. The project is correctly set up as a mathematically rigorous, type-driven trading assistant. here is another one: ...
Things begin to move way too fast, at least for me. There is some amazing fact, which shows that an intuitive understanding can also be valid. I remember reading the memest book of the time – “eXtreme Programming Explained” (by still sober and sane Kent Beck), and trying (probably just like everyone else at the time) to “distill” some grains of “wisdom” from the torrents of “mostly bullshit”. The real take away from the whole manuscript (at least for me) was that writing tests is what really change everything, in particular, they are, indeed, allow quick, confident and “cheap” refactoring and thus really “facilitate change” and, yes, actually speed up the development process. ...
For a quite long time already I sort of “ran in the background” this question – “how they bridge the semantic gap between verbiage and the code?” In the context of a well-written textbook (extremely rare, just 50 or so in existence) the code examples immediately follow or even intersperse the explanations. Most of the internet content is nothing like that. The semantically closest entities in the code are specially formatted comments that are used to generate [an appearance of] “documentation”, with a modern fashion to mention some core concepts being used. This kind of well-documented (enforced by the strict rules) code one would find in placed like Google’s monorepo and other megacorp inner code bases. Almost noting this strict can be found on Github (the primary source of all training). ...
https://karpathy.bearblog.dev/year-in-review-2025/ In this episode @karpathy blessed us all with another blogpost. While his wording is much more careful and even nuanced, there is still a lot of bullshit in it. It way less outrageous bullshit as in the Friedman poocast and around that time, but still. Here are some excerpts: With vibe coding, programming is not strictly reserved for highly trained professionals, it is something anyone can do. … But not only does vibe coding empower regular people to approach programming, it empowers trained professionals to write a lot more (vibe coded) software that would otherwise never be written. ...
Okay, lets look at the “better side” of things. The good thing about using LLMs is that you do not have to deal with Google Search and any fucking Social Media. Imagine a painfully typical scenario – you want to clarify or better understand something you already vaguely knew or at least aware of. You type a query into Google Search, and you get… a fucking CEO fucked-up list of Ad-infested links to various web pages – either the largest social media containment boards (StackOverflow, Reddit, Medium), or some CEO’d blogs, when you are either greeted with a wall of text (usually directly pasted from tutorials and docs), ads, pop-ups, and other distractions, or some narcissistic asshole’s low-effort over-verbose crappy verbiage about “how fucking smart he is”. ...
Just like a spontaneous, “natural and organic” continuation to the previous post (which implicitly confirm that it has properly captured at least some aspect of reality [as it is]). I have had to delete some nice movies in order to download and try that over-hyped “5M downloads” Nvidia’s meme-model Nemotron-3-Nano-30B" I have a small set of highly sophisticated prompts which I use to measure the apparent quality of a generated slop of the 4 major data-center-sized LLMs. ...