Summary

Normal Computing’s work spans an AI-assisted EDA stack for a closed, punishingly expensive chip-design toolchain. Thomas Ahle describes a path from human intent through Verilog/RTL, optimization, formalization and verification to tape-out. A commercial tool may cost roughly “$10,000…for one CPU kernel”; a million-agent data center would imply about $10 billion in licenses. His swarm generated more than 500,000 lines in 43 days, while roughly 20 GPT agents have kept progressing for around six months.
Agentic output is scaling faster than grounded understanding, making correctness—not code generation—the constraint. Tim calls the result a possible “spaghetti monster” and a source of “understanding debt.” Thomas admits the bet is “escape velocity from code complexity,” with models improving faster than their code deteriorates. ProgramBench’s roughly 150–170 programs initially yielded 0% complete passes, and even 70–80% test scores prompt the harder question: “did it get any of them actually right?”
Formal proof only protects a design when AI has faithfully translated human intent into the formal specification. Proof or disproof can provide clean verifier rewards, but auto-formalizing thousands of pages is brittle: a few wrong words or numbers can produce an irrelevant theorem. Separate design, test and coverage teams provide partial independence; repeated runs add useful disagreement but not true orthogonality, so adoption remains “a trust exercise.”
Normal’s released CN101 chip makes noise itself the computation for a narrow class of probabilistic workloads. An array of capacitors connected by programmable resistances is driven by noise so the circuit follows stochastic differential equations; the resulting behavior is related, “sort of,” to the inverse of the encoded matrix. The test is whether scaled benchmarks validate the approach beyond today’s narrow use cases.
Hardware acceleration is a co-design problem, so a spectacular component speedup can still be a false economy. If inference currently uses only about 10% of a GPU, eliminating that bottleneck could offer roughly a 10× gain in that slice before another stage dominates. Diffusion hardware likewise matters most if models are redesigned to “go all in” on cheap randomness. The guest favors hybrids: learned intuition plus optimized classical search, as in Stockfish’s fast neural evaluation inside a traditional engine.
Continual learning could turn agentic systems into abstraction-building machines, but it disrupts alignment and serving economics. The guest says models form abstractions during pre-training—Mistral’s code intuition is the example—but do so poorly live. He thinks Dario may regard on-the-fly learning as a safety risk because it can drift from a safe checkpoint. Live weight updates also break shared-model serving, though per-user LoRAs or always-adapting hardware may offer routes. Tim argues that Claude already behaves adaptively as a broader ecosystem of users, tests and retraining.
The largest execution risk is human and organizational: AI can raise performance while eroding competence, review norms and shared code. Tim calls it “the most deceptive thing ever created in human history”; the guest’s sharper formulation is, “it’s not just that it’s getting smarter, it’s also that humans are getting dumber.” Their mitigations are deliberately frictional—type code by hand, limit parallel projects, preserve expert review, and find teamwork structures better than everyone watching ten private agents.

Deep dive

1. EDA economics slow AI adoption in chip design

Thomas Ahle describes a background in theoretical computer science and algorithms for high-dimensional data, including locality-sensitive hashing, before moving into thermodynamic computing. Normal Computing’s broader stack aims to take a designer from intent through RTL, optimization, formalization and verification to tape-out—something he compares to “the Lovable for chip design.”
He describes Verilog as a “super-parallel programming language” whose constructs map onto hardware. Engineers compile RTL into netlists and schematics, then simulate and formally verify the design before sending it to a fab; unlike software, fabricated mistakes cannot simply be “fixed in prod.”
The toolchain lacks software’s open-source ecosystem. A commercial simulator or verifier may cost about $10,000 “for one CPU kernel,” so the exchange estimates that scaling to a million agents could mean roughly $10 billion just for licenses—before paying for the computers themselves.
That scarcity also starves hardware AI: little open-source code is available for pre-training, and agents cannot cheaply access the tools needed for reinforcement learning. Python and JavaScript therefore feel “day and night” ahead of hardware workflows.
The paranoia is economically rational. Thomas cites the famous Intel division bug of the 1990s as costing between $500 million and $2 billion, with other tiny escaped bugs nearly bankrupting companies; hardware is consequently a natural home for formal methods.

2. Half a million generated lines create an understanding-debt bet

Thomas’s Verilog-simulator project produced more than 500,000 lines in 43 days; he also describes roughly 20 GPT agents running for around six months and still progressing. His explicit bet is “escape velocity from code complexity”—models improve faster than their generated code becomes unmanageable.
Tim questions the upgrade illusion: Fable suddenly makes 4.8 look terrible, just as 4.8 displaced 4.6. Thomas concedes it could be “smoke and mirrors,” but says three days of Fable access cleaned up some GPT-5.5 mistakes and produced more progress on objective tests; that evidence earned some trust.
ProgramBench, which Thomas thinks Facebook released, contains roughly 150–170 programs, including FFmpeg. Models initially scored 0% because none passed every test; reporting 70–80% of individual tests obscures that a program failing 20–30% is probably not correct.
Tim doubts deep structure can be recovered from behavior alone. Thomas counters with codec reverse engineering: people infer an unknown format from encoded blobs, screenshots or clips, and priors about transforms or chunking, iteratively visualizing output until the movie appears. Tim reframes this as a “generation–discrimination asymmetry”; Thomas likens it to A* search pruning.

3. Intelligence needs reusable abstractions, not just longer searches

Tim argues that LLMs can display intelligence through “combinatorial closure”: given useful primitives, a model can hill-climb and compose computational structures. The guest agrees that higher-level abstractions in a better pre-trained model can make subsequent reinforcement learning more effective, but live systems rarely add discoveries to a reusable library.
The guest thinks abstraction does happen during pre-training—Mistral’s apparent intuition for bugs in Normal’s codebases is his example—but agrees that continual learning is missing during live use. Tim also describes Claude as an adaptive ecosystem: users run tests and counterfactuals, those experiences are retrained, and later users inherit the resulting abstractions.
The capability is fraught. The guest thinks Anthropic may be one of the companies wary of continual learning and recalls Dario saying that live adaptation could be a safety risk because an agent might drift away from its aligned “safe checkpoint.” The attribution and wording are presented cautiously in the conversation.
Serving would need redesign too. Updating weights per user prevents providers from sharing one fixed model across customers; the guest mentions a shared base with LoRAs, similar to something he associates with Thinking Machines, while acknowledging that continuous updates remain operationally difficult.
On chain of thought, the guest focuses on giving a model state and workspace in which to operate. He suggests that a simple LLM-like system with access to such a persistent process could, in principle, have the representation capacity of a universal Turing machine; whether it can learn to exploit that capacity remains the empirical question.

4. AI could turn custom silicon into the next CUDA kernel

Tim frames an ASIC as intelligence crystallized: compress a complicated task into its best representation, then bake it into non-adaptive hardware. The guest agrees that this can make current models extremely efficient, but warns that locking hardware too tightly historically constrained software innovation; Nvidia’s flexibility left room for experimentation, even while steering AI toward matrix multiplication.
AI-assisted EDA shortens that lock-in cycle. The guest imagines developers creating specialized circuits as casually as CUDA kernels: invent an algorithm, ask AI to design and optimize its circuit, check correctness, then exploit improved batching at the fab.
The resulting loop qualifies as “recursive self-improvement”: AI helps build better software and hardware, which then improves AI. The guest remains drawn to the opposite endpoint too—flexible chips that learn on-device instead of freezing every abstraction into silicon.
Analog memory may make continuous learning practical rather than optional. Basic capacitors require refreshing, while analog resistive memories can struggle to retain values; if inference and learning continue together, adaptation itself can refresh the state, closer to the guest’s picture of synapses that “are always adapting.”
Tim connects this to the performance-versus-competence debate through Chomsky’s bulldozer analogy and his comparison of Deep Blue to a bulldozer winning an Olympic weightlifting contest. The guest responds that if AI is genuinely doing language, systems that do it differently from humans could still illuminate the abstract concept of language.

5. Formal verification is only as good as the formalized intent

The guest separates auto-formalization from proof. The first converts a human specification into something like Lean; the second proves that code satisfies it. Verifiers create strong reinforcement-learning environments for proving or disproving a formal statement, but they cannot tell whether that statement captured what humans intended.
AlphaProof’s useful training trick, as the guest tells it, was requesting “a proof or disproof.” A mistranslated statement could still generate training signal because the model might prove it false; for the 2024 IMO problems, however, correct formalization mattered and was performed by hand.
Tim adds that AlphaProof used Lean 4 despite limited Lean 4 material, requiring a Lean 3-to-Lean 4 converter and substantial human repair. He also notes that a newer model that won gold at the IMO did not use formal verification in the same way, reinforcing the idea of a spectrum rather than a binary.
Hardware raises the difficulty from a paragraph to thousands of specification pages. “A couple of words wrong” or a few mistaken numbers can make the resulting proof irrelevant. Chipmakers respond with orthogonal design, testing and functional-coverage teams, effectively testing the tests and checking every requirement off.
Multiple AI runs can expose disagreement because long generations contain enough entropy, but the guest does not call identical models genuinely orthogonal. Tim’s broader point is that assurance may remain a spectrum of tests, proofs, visual inspection and independent perspectives.
The conversation also rejects the idea of one uniquely correct formal representation. The same mathematical or hardware intent can be represented in multiple ways, and alternative representations may help both model performance and the legibility of the final artifact.

6. System-level hardware needs more than cycle-perfect proofs

Cycle-level properties—exact behavior at every clock—fit SystemVerilog Assertions, including for adders, arithmetic circuits and cryptographic hardware. Protocol-level questions such as deadlock, livelock, timing consistency and shared-resource conflicts call for higher-level formalisms such as TLA+ and timed Petri nets.
The guest’s DRAM example makes the distinction concrete: activating a row requires waiting for data to travel before reading, capacitors need periodic refreshing, separate banks can work concurrently, and shared circuitry introduces dependencies within banks, across banks and across bank groups. A timed Petri net represents this parallel choreography without specifying every gate.

7. CN101 makes thermal noise do probabilistic math

The guest says he came to Normal Computing after working at Facebook on probabilistic computing and Bayesian neural networks. Posterior inference could require many repetitions with different random seeds or analytical approximations. His provocation is that manufacturers spend enormous effort eliminating electrical noise, while probabilistic software adds randomness back: “why not try to build a chip that’s just inherently random?”
Normal’s first silicon, CN101, uses an array of capacitors linked by programmable resistances. Once noise is injected, the physical system follows stochastic differential equations; the guest says its behavior corresponds “sort of” to the inverse of the matrix encoded in the circuit, which can be captured through averaging.
The present target is narrow, and the guest emphasizes co-design over universal claims. CN101 is an early implementation of a new computational paradigm; the decisive evidence will be benchmarks as the architecture scales and as models are redesigned around abundant physical randomness.
Bayesian uncertainty also becomes less straightforward in generative AI. A distribution over one output once had obvious value; for a sequence that explores ten options, backtracks and produces a final answer, users care about trust in the conclusion—not uncertainty over one particular token.
The guest’s earlier experiment made models gather evidence, estimate its likelihood under competing answers and combine it with Bayes’ law. A manually calculated neuro-symbolic version performed well in an internal prediction game, but telling the model to apply Bayes itself did slightly better—perhaps, he hedges, because it discounted probabilities it had “bullshitted.”

8. Co-design determines whether thermodynamic speedups survive

The guest’s warning is that specialized hardware can accelerate the wrong slice. If inference currently uses only about 10% of a GPU, fixing that bottleneck might yield roughly a 10× gain in that slice; afterward another component dominates. A diffusion accelerator similarly disappoints if a conventional neural network elsewhere sets total latency.
Existing algorithms were shaped around GPUs, where sampling huge numbers of Gaussian variables is unattractive. Faster random hardware offers an immediate gain, but the larger opportunity requires new models that “go all in” on the newly cheap operation rather than preserving an architecture built to avoid it.
The guest rejects using LLMs for every computational layer merely because they could emit binaries or assembly. Cryptography, big-number arithmetic, compilation and synthesis contain brute-force loops where optimized classical algorithms remain far faster; learned knowledge should guide search, then hand work to the right mechanism.
Stockfish is his model for the hybrid: a traditional high-speed chess search whose evaluation function became a shallow, wide neural network that updates extremely quickly. It outperforms the best open-source AlphaGo-type chess engines by combining intuition with structured search.

9. AI productivity is breaking competence and collaboration

Tim argues that software once canalized complexity into shared interfaces such as spreadsheets; agentic coding instead creates personalized webs “like bash scripting on steroids.” The guest sees open source fragmenting as people regenerate code from scratch rather than converging on maintained libraries, even when the private result is locally more efficient.
The conversation also touches product and tool economics. Tim uses Notion through an MCP or CLI interface rather than paying for agent calls at API prices; the guest says API pricing is “killing innovation” in that space and mentions account-based access as a possible alternative.
The guest adds that specialized tools encode accumulated domain knowledge, so agents extracting and distilling that knowledge could make the tools themselves strategically valuable.
The epistemic failure is sharper outside one’s expertise: Tim describes “AI psychosis,” in which Claude convinces users that mediocre papers or code are excellent while experts spot the defects immediately. The guest says this breaks the social contract—why spend time reviewing something its sender may never have read?—and floods technical communities with unread AI-generated work.
Their core warning is dependence masquerading as understanding. “It’s not just that it’s getting smarter, it’s also that humans are getting dumber,” the guest says: people summarize papers instead of reading them and inherit outputs without their brains “going through the motions.”
The guest’s countermeasures include typing generated code by hand, warning employees before copy-paste and resisting the fifth parallel project until the first few are understood. These frictions matter because Normal must train AI engineers in hardware and hardware engineers in AI rather than merely maximize immediate output.
Teamwork remains unresolved when everyone watches ten private agents. The guest recalls an Anthropic team saying everyone independently coded a version and they selected the best—an effective human ensemble, but “it does remove all of the teamwork.” Tim closes the episode’s governing tension: the industry is collectively betting that performance matters more than competence.

170: With 陈哲’s “Embodied Quarterly 26Q2”: The World-Model Gale Keeps Blowing, and Those Who Don’t Want Labels $FOX dropped 25% buying $ROKU. Is the market wrong? | Accrued Interest