it's very interesting how many replies i've gotten about maintainability and clean code being still important. i would argue that that is no longer true and we all need to update our priors on what Good Code really means in 2026.
clean code has always come at a cost - performance. indirection and making code readable/understandable for a human is not free, it often comes at the cost of worse performance. we have historically been okay with this because of Moore's Law and the fact that most code is not on the hot path.
these principles also came from a time where humans maintained code. it made sense to optimize for humans then, but it makes less sense now when agents are already writing all the code. we will in fact probably discover and come up with new principles: principles of agent friendly architecture (i plan to write more thoughts about this soon)
codebases have always contained slop. we have always been okay with this because code rarely needs to be perfect, outside of mission critical "hard" (eg embedded) software.
swe is a unique form of engineering because you're often building something that constantly evolves and is almost organic - user tastes change, your mental models evolve, and features come and go.
admittedly, i and many others who've been coding for a long time were initially (like back in 2024) skeptical that agents would write production code. "but what about all the slop that would enter our beautiful codebase?".
well, even before, we had human slop, and there was a lot of it! if we're being truthful, most people call "code i didn't write" slop. the reality is that 99% of people (i include myself in that number) don't even know what Good Code looks like, let alone be capable of writing it. i would propose that Good Code is:
• correct
• bug free
• fast and cost efficient to run
it has always been exceedingly difficult and expensive to write truly Good Code, because for the longest time (maybe @bendlang will change that), code was not something you could cheaply and formally guarantee to have all 3 of these properties. this is why writing hard software is much more difficult and expensive, because depending on the use case, you may only get one chance and so you have to be right from the start.
but the vast majority of software we use does not need to be Good Code to provide value to users. in fact, it is very likely that most software we use is not formally verifiable! we accepted some bugs in exchange for velocity and progress, so we rely on tests and o11y instead and have adopted a more incremental approach. this is a good thing!
agents help us move faster, and if you're open to the idea, are capable of helping us write better code. it won't be Good Code (that is still expensive), but it is likely to be much better on average at scale.
the new craft of swe is to figure out how to do this. it's your job now! if your productivity with and without agents is not significantly different, you're doing something wrong. but it's not too late to embrace it and use it as an opportunity to learn a whole new skill tree
swush retweeted
Terence Tao: The math behind today’s LLMs is actually simple.
Training and running them mostly uses linear algebra, matrix multiplication, and a bit of calculus, material an undergraduate can handle. We understand how to build and operate these models.
The real mystery is why they work so well on some tasks and fail on others, and why we cannot predict that in advance. We lack good rules for forecasting performance across tasks, so progress is largely empirical.
A key reason is the nature of real-world data. Pure noise is well understood, perfectly structured data is well understood, but natural text sits in between, partly structured and partly random. Mathematics for that middle regime is thin, similar to how physics struggles at meso-scales between atoms and continua.
Because of this gap, we can describe the mechanisms but cannot yet explain capability jumps or give reliable task-level predictions. That mismatch, simple machinery versus hard-to-predict behavior, is the core puzzle.
----
Video from Prof @Briankeating YT Channel (Link in comment)
swush retweeted
this is going to seem like a shill tweet, but honest to god install the @AntithesisHQ skill-pack if you care about catching correctness faults during development. it's useable and valuable without having access to our multi-verse debugger/determinator.
github.com/antithesishq/anti…
swush retweeted
"If you can build a verification system and give proper direction, AI can produce a highly complex, highly sophisticated piece of software and it can continue to refine it until it just works." - @pauldix
pauldix.com/the-end-of-progr…
swush retweeted
Software quality now depends on the constraints you set around your agents.
When humans manually wrote most of the code we could look at the code itself for signs of quality. Is it clean? Is it thoughtful? Is it fast? Can another engineer understand it? Does it have tests?
Agents can now generate more code than people can read. When code generation scales beyond review, quality - checks for one or more of correctness, maintainability, security, performance etc - increasingly has to live somewhere else.
It moves into the harness, environment and operating system around the agent.
This can be the tests and deterministic checks that decide what the system is allowed to do (amongst others). Your constraints are what may eventually enable loops of agents to deliver production software reliably. They can include unit tests, property tests, acceptance tests, mutation testing and quality metrics.
This back-pressure lets the system resist bad work before it becomes somebody elses problem.
Set your constraints. They decide whether the code your agents generate is good enough to ship.
swush retweeted
Coding with AI showed you could give models powerful tools and dramatically improve their usefulness.
We're seeing the same thing happen now for all knowledge work. The agent can use the computer as you would and gain context from all the apps you use.
The future is exciting!
swush retweeted
Pulled the trigger today and switched 100% of Lindy traffic to DeepSeek v4, churning from Anthropic models.
Saves us millions of $ and we're actually seeing an *increase* in performance on many core use cases. Transformative for the business.
swush retweeted
💡Recent insight: gaslighting @claudeai seems to improve code quality >90% of the time.
“You overengineered this, there is a simpler way”
“There is a smaller delta that buys us most of the benefits”
“There is a more elegant way”
“This is not architecturally coherent”
…before I even read its code. 😆
swush retweeted
React Doctor v2 is here
Your agent writes bad React code, this catches it
Works with Next.js, Vite, React Native. Fix your app in minutes
npx react-doctor@latest
swush retweeted
kimi K2.6 vs K2.5, mythos, opus 4.7, and cursor composer 2 (based on K2.5) on every benchmark i could find
tl;dr: it's a really really good model
Meet Kimi K2.6: Advancing Open-Source Coding
🔹Open-source SOTA on HLE w/ tools (54.0), SWE-Bench Pro (58.6), SWE-bench Multilingual (76.7), BrowseComp (83.2), Toolathlon (50.0), Charxiv w/ python(86.7), Math Vision w/ python (93.2)
What's new:
🔹Long-horizon coding - 4,000+ tool calls, over 12 hours of continuous execution, with generalization across languages (Rust, Go, Python) and tasks (frontend, devops, perf optimization).
🔹Motion-rich frontend - Videos in hero sections, WebGL shaders, GSAP + Framer Motion, Three.js 3D.
🔹Agent Swarms, elevated - 300 parallel sub-agents × 4,000 steps per run (up from K2.5's 100 / 1,500). One prompt, 100+ files.
🔹Proactive Agents - K2.6 model powers OpenClaw, Hermes Agent, etc for 24/7 autonomous ops.
🔹Claw Groups (research preview) - bring your own agents, command your friends', bots & humans in the loop.
-
K2.6 is now live on kimi.com in chat mode and agent mode.
For production-grade coding, pair K2.6 with Kimi Code: kimi.com/code
-
🔗 API: platform.moonshot.ai
🔗 Tech blog: kimi.com/blog/kimi-k2-6
🔗 Weights & code: huggingface.co/moonshotai/Ki…
Hyperbridge exploit story:
>single audit, no bug bounty
>rude to whitehats, publicly mocking their efforts
>April Fool's - "Security Incident Report xD lolllz"
>claims they're unhackable
>gets hacked 2 weeks later - "Bridge update!"
Always respect the whitehat efforts, always🙏
$DOT dump
#CertiKInsight 🚨
We have seen an exploit on the @hyperbridge gateway contract.
skylens.certik.com/tx/eth/0x…
The attacker slipped through a forged message to change the admin of Polkadot token contract on Ethereum and profited ~$237K from minting and selling 1B tokens.
Stay Vigilant!
30
































