swush (@swushme) header
swush (@swushme) profile picture

🚀 Aggregating best swap rates across Polkadot’s multichain

Polkadot
Joined March 2024
Photo by swush (@swushme)Photo by swush (@swushme)Photo by swush (@swushme)Photo by swush (@swushme)Photo by swush (@swushme)Photo by swush (@swushme)Photo by swush (@swushme)Photo by swush (@swushme)Photo by swush (@swushme)Photo by swush (@swushme)
Replying to @TheKusamarian
GM Polkadot & Jay
4
1
9
705
swush retweeted
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
424
225
150
4,367
312,400
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)
125
834
75
4,975
496,116
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…
10
14
2
303
19,286
"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…
27
32
10
319
42,288
swush retweeted
Rough tier list of where I'd put every major model right now
1,465
742
536
14,894
4,236,349
swush retweeted
Replying to @samsaffron
I don't think many humans are going to be reading or writing code in 5 years, so I don't really think it matters.
77
126
74
1,651
389,048
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.
90
157
21
1,263
468,051
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!
95
70
15
1,078
55,820
swush retweeted
[blog] A new era for software testing: antirez.com/news/168
24
74
10
612
63,537
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.
171
160
138
2,606
961,278
💡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. 😆
59
95
40
1,907
562,785
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
130
349
50
5,140
788,596
swush retweeted
AI storytelling is crazy now chatgpt image 2 can turn any story idea into storyboard with cast design.. then feed it to seedance 2 to get a full film scene.. this workflow is crazy on arcads step by step tutorial with prompts:
151
807
49
6,438
640,613
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…
47
132
21
1,666
151,765
swush retweeted
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🙏
56
121
31
1,147
82,422
$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
swush retweeted
The first rule of career planning: Do not plan your career. pmarchive.com/guide_to_caree…
66
734
142
5,759
1,042,781