
@danja@fosstodon.org
Castiglione di Garfagnana
Joined November 2006
- Tweets25.4K
- Following2.9K
- Followers2.1K
- Likes4.7K
Danny Ayers 🌳 retweeted
This should ideally in a future iteration be fulfilled from a single graph query, but it does already nicely showcase benefits of the hybrid neurosymbolic approach:
Using ASIMOV, show me Semantic Web OGs from my LinkedIn connections
Danny Ayers 🌳 retweeted
🟡🟡[STIMA #PROVVISORIA] #terremoto Magnitudo tra 3.9 e 4.4 ore 08:13 IT del 25-03-2026, prov/zona Massa-Carrara #INGV_45417702
Danny Ayers 🌳 retweeted
XML is dead, they said 😂
platform.claude.com/docs/en/…
Danny Ayers 🌳 retweeted
Sounds incredible until you read the fine print. The compiler generates less efficient code than GCC with all optimizations disabled. It doesn’t have its own assembler or linker. It can’t produce a 16-bit x86 code generator. And Carlini himself says it has “nearly reached the limits of Opus’s abilities.” New features and bugfixes kept breaking existing functionality.
So what did $20,000 and two weeks actually buy? A compiler that passes 99% of GCC’s torture tests but can’t match the output quality of a tool that’s had 37 years of human engineering. That’s the constraint nobody’s pricing in.
The real story is in the cost curve, not the capability demo. $20,000 for 100,000 lines means $0.20 per line of generated code. A senior compiler engineer costs roughly $150/hour. At maybe 50 polished lines per hour for something this complex, that’s $3/line. AI just did it at 15x cheaper, and it will only get cheaper from here.
But the code isn’t equivalent. The AI version needs a human to finish the assembler, fix the linker, optimize the output, and prevent regressions. Those are the hardest 20% of the problem, and they represent 80% of the engineering value. Anthropic built the demo. Shipping the product still requires humans.
This tells you exactly where we are in the autonomous software timeline. AI can now produce impressive first drafts of complex systems at trivial cost. Turning those drafts into production software still requires the judgment that costs $300K+ per year in compiler engineer salary. The gap between “compiles the Linux kernel” and “replaces GCC” is measured in decades of accumulated engineering wisdom that no model has internalized yet.
The companies that understand this will use agent teams to generate the 80% and hire engineers to finish the 20%. The companies that don’t will ship $20,000 compilers that produce slower code than a free tool from 1987.
New Engineering blog: We tasked Opus 4.6 using agent teams to build a C compiler. Then we (mostly) walked away. Two weeks later, it worked on the Linux kernel.
Here's what it taught us about the future of autonomous software development.
Read more: anthropic.com/engineering/bu…
Danny Ayers 🌳 retweeted
Everyone's sharing their OpenClaw setups. Most skip security entirely.
I spent a week hardening mine: Dedicated machine, Tailscale, command allowlists, read-only tokens.
The security-first guide I wish existed when I started.
🦞🔒
teapawt.net/JordanLyall/status/201…
Danny Ayers 🌳 retweeted
I'm Boris and I created Claude Code. Lots of people have asked how I use Claude Code, so I wanted to show off my setup a bit.
My setup might be surprisingly vanilla! Claude Code works great out of the box, so I personally don't customize it much. There is no one correct way to use Claude Code: we intentionally build it in a way that you can use it, customize it, and hack it however you like. Each person on the Claude Code team uses it very differently.
So, here goes.
Danny Ayers 🌳 retweeted
What if I told you that your AI agent isn't "stupid"—it’s just working without a map? 🗺️
We’ve all seen it: You give an LLM a complex task. It starts strong. But by step 7, it’s hallucinating actions and ignoring rules you gave it 30 seconds ago.
The fix isn't better reasoning. It's better representation. 🧵👇
2/
Here is the invisible problem with current prompting (even Chain-of-Thought):
It asks the model to solve a physics problem without drawing a free-body diagram first.
The AI is trying to hold the entire state of the world—variables, rules, constraints—in its "head" (latent space) while simultaneously trying to solve the puzzle.
3/
Cognitive science calls this a "Mental Model."
When humans solve hard problems, we don't just guess.
Engineers sketch blueprints. 📐
Programmers write pseudo-code. 💻
Scientists define variables. 🧪
We stabilize the problem before we attempt the solution.
4/
A fascinating new paper, "Model-First Reasoning LLM Agents" (Kumar & Rana, 2025), just dropped.
Their hypothesis? Hallucination is a symptom of reasoning over an unstable internal model.
If the foundation is shaky, the logic collapses.
5/
So, they propose a radical (but simple) shift: Model-First Reasoning (MFR).
It splits the job into two distinct phases:
Phase 1: 🛑 The Architect. Build the model. List entities, states, and hard constraints. Do not solve.
Phase 2: ✅ The Builder. Now execute the plan using only the model from Phase 1.
6/
Think of it like building LEGOs.
The "Chain-of-Thought" approach is grabbing a handful of bricks and guessing where they go.
The "MFR" approach is opening the instruction manual, sorting the pieces by color, and then starting step 1.
7/
The Experiment:
They tested this on "constraint-heavy" tasks—like medical scheduling or complex logistics.
The results?
📉 Drastic drop in rule violations.
🚫 Fewer "implicit assumptions" (guessing).
🧠 Plans that actually make sense from start to finish.
8/
Why does this work? It’s called "Soft Symbolic Grounding."
By forcing the LLM to write down the rules first, you turn a fuzzy language task into a structured logic task.
If the agent tries to cheat later, the model acts as a guardrail. "Sorry, you can't move that. Your model says it's heavy."
9/
(I know, it sounds obvious now that you see it. But how many of our prompts actually do this?)
We usually say: "Solve this step-by-step."
We should be saying: "Define the rules of the game. Then play it."
10/
🛠️ The Toolkit: Try this Prompt Today
Don't just take my word for it. Next time you have a complex reasoning task, inject this block at the start:
"Before solving, explicitly construct a model of the problem.
List:Relevant Entities
State Variables (what changes?)
Actions (what is allowed?)
Constraints (what is forbidden?)
Once defined, generate the plan strictly adhering to this model."
11/
The Big Takeaway:
We've been obsessed with the process of reasoning (CoT, ReAct).
We forgot about the object of reasoning.
Structure precedes solution.
If you want reliable agents, stop letting them improvise the world. Make them build it first. 🏗️
12/
This paper is a brilliant bridge between classical AI (which loved explicit models) and modern GenAI (which loves vibes).
Read the full paper: "2512.14474v1.pdf"
I’m curious: Have you tried separating "setup" from "solution" in your prompts? What happened? Let's discuss below! 👇
Danny Ayers 🌳 retweeted
A large solar-powered AI satellite constellation would be able to prevent global warming by making tiny adjustments in how much solar energy reached Earth
Danny Ayers 🌳 retweeted
Sitcoms will never be the same.
This is fully AI generated in LTX-2 teapawt.net/fofrAI/status/19828130…
Danny Ayers 🌳 retweeted
Full API serving is up for @FishAudio
- TTFT <500 ms
- input/output streaming
- Unlimited voice clone slots
- scalable concurrency limit
We also open-sourced S1-Mini on GitHub and Hugging Face. Join us in shaping the future of human-centered voice AI.
💻 github.com/fishaudio/fish-sp…
Danny Ayers 🌳 retweeted
The paper introduces a tool based framework Ax-Prover, that turns general LLMs into Lean theorem provers across mathematics and quantum physics.
On a new QuantumTheorems set it solves 96% in 1 run per problem.
The big deal is that a tool-using LLM can produce Lean proofs that pass strict checks across very different fields.
It connects the model to Lean through the Model Context Protocol so it can open files, inspect goals, search theorems, and use compiler feedback.
The system has 3 agents, an Orchestrator that routes work, a Prover that writes proofs, and a Verifier that checks the code.
The Prover plans the proof, splits it into small helper steps, fills in tactics, compiles, and fixes errors.
Lean only accepts code that compiles with 0 errors and no sorry placeholders, so every accepted proof is fully checked.
Across abstract algebra and quantum datasets it beats specialized provers, and a plain LLM without tools does far worse.
The point is generalization and practicality, it works across domains without retraining for library changes.
----
Paper – arxiv. org/abs/2510.12787
Paper Title: "Ax-Prover: A Deep Reasoning Agentic Framework for Theorem Proving in Mathematics and Quantum Physics"
Danny Ayers 🌳 retweeted
What if I told you an AI's 'mind' isn't a chaotic mess of code, but has a hidden 3D map of meaning that almost perfectly mirrors our own psychology?
Would you believe me?
A new paper just dropped, and it completely rewired my brain about how AI works. 🤯
🧵 A thread...
You know that frustrating moment when you're trying to steer an AI? You ask it to be more "creative," and it suddenly starts making factual errors.
These weird side-effects, or "off-target effects," have always been treated as random bugs in the system.
Except they're not random at all.
Researchers dug into the embedding matrices of LLMs (the part of the model that gives meaning to words) to map out the 'geometry' of concepts.
They defined directions for 28 different semantic scales, like kind-cruel, strong-weak, or beautiful-ugly.
And here's the first bombshell: The way the AI organized words along these scales was wildly similar to how humans do.
An AI's internal 'rating' of a word like "peace" on a "good-bad" scale almost perfectly matched data from human surveys. The AI has human-like intuition.
But that's not even the interesting part.
They took all 28 of these distinct conceptual directions and used PCA to see if there was a deeper structure.
And something weird happened. All that complexity collapsed.
It turns out, you can explain most of the meaning with just THREE core dimensions:
Evaluation (good vs. bad)
Potency (strong vs. weak)
Activity (active vs. passive)
If this sounds familiar, it's because it's the exact same 3-factor structure psychologists discovered in human language 70 years ago!
(I know, right? My mind was blown too.)
Here's where it all clicks. This is the key to the whole mystery.
Concepts aren't stored in neat little boxes. In our minds, and in the AI's, concepts that are related are geometrically close.
The direction for 'kind' is naturally aligned with 'beautiful.' 'Strong' points in a similar direction to 'big.'
They are entangled meaningfully.
And this solves the puzzle of "random" side effects!
When you nudge a word in the AI's mind to be more 'beautiful,' you're also dragging it along the 'kind' axis because their vectors are aligned.
The side effect isn't random—it's predictable geometry. The size of the effect is proportional to the angle between the concepts.
Now, you might think the solution is to force these concepts apart to get more control. That's what some previous methods tried to do.
But this research says that's a terrible idea.
It's like trying to teach a child that 'soft' has nothing to do with 'gentle.' You don't gain control; you just break their understanding of the world. The entanglement is a feature, not a bug.
Here’s what this means for you:
Next time you see an AI give a weirdly 'off' response, don't just think 'bug.' You're getting a glimpse of its hidden conceptual map.
That "off" association is a clue to how it connects ideas. You're seeing the geometric relationships in its mind in real-time.
This research completely changes how I think about AI.
It’s not some alien intelligence operating on unknowable logic. It's a mirror, reflecting the deep, hidden, and sometimes weird structures of our own collective language and thought.
Makes you wonder what other human patterns are hiding in the code...
If you want your mind blown too, go read the paper. Incredible work by Austin C. Kozlowski, Callin Dai, & Andrei Boutyline.
Paper: "Semantic Structure in Large Language Model Embeddings"
arXiv:2508.10003v1
Danny Ayers 🌳 retweeted
Novelty rhyton - wine cup! So much more fun to be drinking when you looked like a pensive cow with every swig. Happy Friday!
Ca. 460 BCE, info card below.
Danny Ayers 🌳 retweeted
Anthropic are massively burying the lede here - they've called this "Upgraded file creation and analysis" (that really does seem to be the official name) but it's actually....
Claude Code Interpreter!
It's sandboxed server-side Python/Node.js code execution for Claude
Danny Ayers 🌳 retweeted
After sudden shaking, there is a rush of visitors using the LastQuake app & the EMSC websites, as well as tweets on Twitter, which alerts the EMSC that a seismic event has probably occurred.👇
Danny Ayers 🌳 retweeted
I’ve finally gotten around to putting together a comparison post that contrasts Knowledge Graphs constructed using RDF versus the Labeled Property Graph (LPG) approach. As usual, I’ve embedded live demos that get to the heart of the matter.
RDF tackles some of the hardest data challenges in existence. Taking that on was never going to be easy—especially when RDF/XML was the starting point and LLM-based natural language processing didn't exist.
There’s a world of difference between a Knowledge Graph constructed using standardized identifiers (e.g., hyperlinks) and one built using labels (as the term “Labeled Property Graph” clearly implies).
🧵0/
Danny Ayers 🌳 retweeted
i roughly think of vibe coders as the new bloggers and vibe coded apps as blog posts - anybody can do it, most people won’t. most who do won’t be significant and most projects will be irrelevant quickly, but some people will have impact and some projects will endure. regardless, the process leads to growth.































