推文

Introducing Magnitude. It's a coding agent that runs entirely on open models. It costs 60% less than Claude Code with no drop in performance. Try it now: npm i -g @magnitudedev/cli Here's how it works 👇 https://t.co/uPvYrHOrW8

1. as a mental model it is more correct to think of fable+ class models as english -> code interpreters - converts your idea into code into "correct" code regardless of problem complexity and output complexity (diff size). Fable 5 will be the worst of this new class of models 2. diff size/complexity is to be managed purely for review: small diffs - in high risk areas of code (auth/identity/data access/network access/money movement) large diffs for code that can be empirically verified (frontend/backend plumbing/code without network or db access/performance code that can be empirically verified) 3. time it takes to ship software is completely disconnected from time to produce the PR - how long the work takes depends fully on ability to review/merge code while managing risk at scale 4. solving the bottlenecks for above matter enormously- linters/testing/CI/shadow mode verification/empirical verification 5. agency matters enormously- what are the biggest bottlenecks to speeding up the loop and eliminating them? what are the problems that need solving and when do they need solving? what does it take to the solution to all of them today? 6. deep understanding of the full stack matters enormously- what problems are worth pursuing? is there a higher level of problem abstraction to address first? should I give it the sub-sub task, the sub task, or the task itself. what are the major risks with this PR (order of importance: security holes/correctness holes/performance holes). is there a higher speed way of producing data that allows me to merge this? should this be run in shadow or in a sandbox or a flag. understanding every line of logic may not be needed but understanding and managing risk matters enormously. 7. the cost of complexity itself is changing. it might be now worth "maintaining" 50% more code to get a 5% performance win. getting the right abstractions matter less because larger refactors are less tedious. code quality nits become huge drag. very likely, a much smarter model will be maintaining your code so worth taking on more technical debt now. taking the time to hand architect and rebuild systems comes with an enormous cost of velocity 8. if it quacks like a duck and walks like a duck, it's a duck. For low risk cases, it might be more sane to treat code chunks (services / functions) as a black box, like we do for neural networks: do full empirical verification only: has code produced correct outputs for the last 10,100,1000,10k inputs ? can we quarantine this large piece of code - no outbound access to network / database ? what happens when this code is wrong? do we get hacked/or crash(memory/cpu)/is an inconvenience? is it internal facing or external? what can we do to address these risks? 9. eventually, logical verification (line by line review) will come at an enormous cost- save it for where it matters and build systems that are tolerant to empirical verification. is there a decorator that prevents db / network access? correctness bugs are significantly easier to rectify than access bugs 10. what are the rails that allow for even faster iteration? code permissions can be opt in - db writes, db reads, network egress (to where?), PII access. how long does it take to get shadow mode data? how many PRs can be tested? What are the categories of diffs

Announcing mattpocock/skills v1 - Achieved a 63% reduction in token cost for skill descriptions - Split skills into model-invocable and user-invocable skills, adding /codebase-design, /domain-modeling, and /grilling - (UPDATED) /writing-great-skills - rewritten from the ground up, encoding my skill-writing best practices - (UPDATED) /diagnose -> /diagnosing-bugs - now model-invocable, awesome for fixing hard bugs - (NEW) /ask-matt: a router skill that teaches you how all the engineering skills work together

The Log Is the Agent

200 lines of markdown to steer a 2,000-line change. @dexhorthy calls that higher leverage. He's right. The highest-impact work in AI-assisted dev happens before any code is written: in the plan, not the diff. Catch him on the Agentic Review podcast ⬇️ https://t.co/Zi5qi2h6yM

AI is so good at backend, but so bad at UI/UX. Any recent models one-shot my new features, but I'd have to spend another 10+ prompts to get the design right.

using AI for coding is a deeply technical engineering craft most people don't approach it as so, and don't get the results we associate with high craft but the ones who do have been sprinting ahead more tokens wont save you, more thinking + skill + llm intuition will have been saying this for almost 9 months now

i have seen enough proof now that using a coding agent is a deep skill it's confusing because the people you see heavily using them produce horrible results but that's because it's a skill! you can get better and the ceiling seems pretty high - this is very exciting to me

Situation 1: dev A thinks approach X is correct, dev B thinks Y is the right way. They argue and try to convince each other. Situation 2: dev A thinks approach X is correct, tells the LLM to implement it. There is SO MUCH learning in Situation 1, lost when using LLMs....

As @GeoffreyHuntley says “it’s just software engineering” ie some stuff is orthogonal to ai and all still true. Book recs include Clean code by @unclebobmartin pragmatic programmer, refactoring by @martinfowler - design patterns by GOF etc etc The other half is experience - as @nayshins says you know something’s bad because you’ve debugged it at 3am or spent weeks undoing some bad pattern

HTML is the new markdown. I've stopped writing markdown files for almost everything and switched to using Claude Code to generate HTML for me. This is why.

No-one has figured out how an eng team should work with agents yet. Be wary of anyone telling you they know how to do it. Keep exploring. https://t.co/QZ3RXEyIzZ