Winkle (@robbwinkle) profile picture

Building AI for the real world. token maxxing. prev: https://nitter.cf/t.co/qB3Y1eZhnG, martech, enterprise consulting, @Techstars

Columbus, OH
Joined January 2009
Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)Photo by Winkle (@robbwinkle)
I agree with most of this. Some of it only works with small teams. But everything is directionally correct. A corollary to removing docs and skills from a codebase for large or regulated organizations is try to remove skills by fixing your data and improve your tools and processes so they aren’t necessary.
EFFECTIVE SWARM RIDING FOR ENGINEERS I think we are entering an era where software development feels a lot more like magic. But you need the right attitude, the right infra, and some incantations. These are some things that have worked well for me & I hope for you! 1/N
18
This is a terrible 0-day: NGINX http2 stack is compromised. Take it offline now if you serve any h2/grpc traffic behind nginx. (k8s ingress-nginx is also impacted and won't be patched, you can wait for forks to fix it, or better move off already)
Pre-auth RCE in nginx is the bug every hacker dreams of finding. It almost never happens. Today we’re disclosing nginx2root: five nginx vulnerabilities, and an exploit that takes an unauthenticated attacker all the way to root. One of themhits the default config. If you run nginx, patch now. Then read: nginx2root.com CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810, CVE-2026-113425
14
34
4
427
63,049
DocuSign wants $8,100/yr from a 15-person team just to sign PDFs. So I built SignuDoc: open source, one-click deploy to your own @vercel account, $0 per seat. White-label branding, full audit trails, tamper-evident seals and your documents never leave your cloud.
996
1,794
467
29,337
4,396,365
building with Managed Agents on the Gemini API? now you can bring your own sandbox with self-hosted environments start building today: ai.studio
75
67
50
822
81,987
Decision Models are the future of agentic security. They can process billions of tokens of telemetry, identify security issues, and help you patch fixes at a scale and cost structure not possible before. We’ve open sourced our models and made it free on Openrouter for a week.
Neat example of how Perplexity used Decider internally In one day it read 1B tokens across 7,000 agent sessions and found flaws that led to 14 fixes to their agent security rules. Both models are Apache-licensed and free on OpenRouter until Nov 19
77
41
9
550
38,484
Guardrails belong between the steps of the agent loop. @coyle_frankp of @UCBerkeley walks through where to validate tool inputs, inspect outputs, and check whether the result makes sense. From Day 1 at AI Engineer Code Summit.
6
10
1
94
6,677
Winkle retweeted
Been playing with some automatic verification techniques in Alchemy Domain. Define invariants on Aggregates (states that must always be true) and statically "prove" or "explore" to ensure they're never invalidated.
8
10
135
4,845
well now @CompleteSkeptic has me worried that even with all of my recursive decision models, i'm still not jevving hard enough... ...time to get back to work
1
11
540
update your boxes /now/ the default user on alpine's aws and azure images take any password longer than 256 characters. yes, any password. yes. i know. yes.
*sshole is out if you run sshd on alpine, openwrt or any musl box with password auth on: update now official writeup: sshhole.com
30
60
14
808
65,700
Winkle retweeted
My further (informed) fantasies about the near future: 1) No CI. Agents prove each change against rules while they write it. 2) Code is a cache: rules stay, code regenerated with better models. 3) No staging, simulation instead. 4) Humans direct in plain words, agents compile that into formal rules, humans don't read the formulas, only examples and counterexamples. 5) Agents find the rules the human never knew to express (and ask to confirm them). 6) The checker catches contradictions between human's rules while they're still directing. 7) Unchecked/unproved code becomes legacy code. 8) Branches come back as experiments (many versions at once, humans pick among winners). 9) Software gets bred, not built. 10) Slop is variation without selection. 11) If UI is generated on the fly, design becomes the rules every generated screen must follow. A checker runs those rules on every generation. 12) Apps evolve from how they're used. 13) Everyone uses their own software version. One product becomes many personal versions, that stay compatible via shared rules.
Next question: why are you still using branches? We talked about PRs. I don't think they make sense anymore, if you rethink them from first principles. Yes, if you only use them to trigger CI, then sure, go ahead. That's a fat commit, not a PR. But for mandatory code review? Knowledge sharing? C'mon. But some of you said: "we use PRs because we use branches! I love to keep my stuff on branches." And I'm here to tell you: you don't need branches! You can just push to main. It's called trunk-based development and the idea behind it is true continuous integration: you continuously integrate your changes with the trunk, the main branch. It's been around for a while, it works. Just yesterday I talked with someone who said they've used it in an org with 400 engineers, without any issues. Ruby, the project, uses trunk-based development. The main idea is that you want to avoid long-lived branches. They're bad, because branches can diverge and merging can turn into a thing. And you don't want routine operations to become a thing. Even when I worked in teams that used PRs and branches, I considered it a smell when a branch lived for longer than a day or two. But when I shared this with others, I'd often get something back like this: "Well, good for you, but no. MY thing, what I'm working on, that can't be done on main. It needs to be on a branch! It has a database migration, it changes the underlying shape, the architecture, it refactors this and changes that. It can't go on main yet! I need to merge it all at the end." And then I'd say: "Nah, I can merge nearly anything continuously in small commits to main. You split things up. Add the column first, merge that, deploy it, now it's out, works, safe. Add the helpers first, merge them, get them out. Want to migrate from legacy pattern A to new pattern B? Don't do it all at once. Add the dependency, then migrate A to B, one by one, safe." If it can be merged in a large change, I bet it can be done in small increments that you merge to main. Yes, there are exceptions, but it's 0.5% of cases, not 50%. But there was a real problem with this approach: it was hard! There's a lot of "meta programming" you have to do: make sure this small first change compiles and runs and the tests work, merge it, get it out, monitor it; then do the next small piece, make sure that works and get it out; then maybe push some still-unused dead code, add a feature flag, add a config variable; or keep both configurations working at the same time, etc. That meant sometimes it was just easier to do it in a big fat branch. But big fat branches are risky! A system that continuously flows is safer than a system that starts and stops in spurts. But -- you guessed it -- here's the good news: Now, with agents, all of these chores are no chores at all! Agents are great at adding feature flags, they're great at splitting up code, they're great at keeping track of three changes and merging them one by one and watching them roll out. They're great at keeping two configurations working for a day. They're great at migrating one by one. In other words: it's now 10x easier to just work on main and make sure everything is continuously integrated and working. It's now easy to make sure the system constantly flows. And look, ... I'm not here to convince you to switch to trunk-based development. Just a ruse to get you to read this. (But also, hey: try it! Pushing to main is amazing.) I'm here to make you RETHINK how you develop software. Don't just use agents to replace your typing. Use agents as the magic code-writing machines they are. Everything that was hard about software development because it involved writing code -- even the meta programming -- has become easier. You can now reach for the stars! But you need to look up.
33
24
12
399
31,547
Winkle retweeted
Okay, let's do this. Isabelle, Lean, and Rocq (formerly Coq*) are theorem provers. They are meant to prove mathematical theorems. We use them for formal verification by either 1) translating a program to the theorem prover (risking a translation error) or 2) using a language built into the theorem prover that extracts into a working binary. Fizzbee, TLA+, Spin, Alloy, Quint, and P are specification languages. They are meant for checking high-level blueprints of programs. After checking the blueprint, you still need to make sure your program matches it, which is a hard problem. Specification languages differ in what they make easy to express. P, Spin, and Fizzbee are designed to be closer to the code implementations. P looks like interacting state machines, Spin looks like C with CSP, Fizzbee looks like a dialect of Python. It's easier to use a codelike specification language and refine it to code, but you can't do as much with it. Alloy, TLA+, and Quint are more abstract. Alloy looks like a bunch of algebraic relationships, TLA+ is a much of logical formula, and Quint is a programmer-oriented (and statically typed) condensation of TLA+. Abstract modeling languages are harder to get started with and harder to represent things, but you can represent a wider class of systems with them. I believe UPPAAL is a specification language for realtime systems. This is a field I have no experience in. It seems a graphical language, though, which would make LLM-assistance difficult. Dafny is a verifiable programming language. It has regular programming language features, but also a bunch of features to express and prove properties of the program. It uses SMT solvers to actually prove the properties, meaning you don't need to learn a proof language (though you need to learn to cajole the solver). Dafny is probably the easiest thing on your list to get started with, but also the least likely to meet any weirder needs you might have. I don't know what Ivy is but some cursory Kagiing suggests it falls in the specification language category. Some other things @spin_lock_init didn't mention: - Other theorem provers: Agda, Metamath - Other abstract specification languages: mcrl2, NuXMV, Event-B - Other verifiable programming languages: Idris, F*, Whiley - There's also using a verifiable subset of a language, like Verus for Rust or SPARK for Ada. So, what you need to pick depends on what you want to do. You'll get the maximum power with a theorem prover. Lean is the de facto language for vibeproving, but Anthropic recently published a post about vibeproving in Rocq so YMMV. If you want to make abstract models of software systems, go for a specification language. Which you choose depends on a lot of factors. If your system can be represented as lots of simple communicating state machines over a network, try P. Spin, I believe, is close to simple C/Go with a network and channels. I have never used Fizzbee. Alloy is good for domain modeling, but struggles with really complicated temporal actions, nested data structures, and largish numbers. Also AIs aren't to good at it (last I checked, in March). Runs fast and makes good visualizations though. TLA+ and Quint are for modeling complex temporal systems. I'm partial to TLA+ but know a lot of people who say Quint is easier to get into. Note P, Fizzbee, and Quint all claim to have features for testing a codebase against a spec. I can't vouch for any of them, though. None of the languages I mentioned (except maybe NuXMV?) are particularly good at modeling sequential, deterministic algorithms. Use Dafny if you need to just write a verified program and don't care which language it's in. I don't think other verifiable programming languages are as user-friendly for the time being. Consider a verified subset if you already know a language and want to just augment it with more correctness. You may need other, more exotic tools depending on your particular needs. Regardless of the above advice, don't be afraid to use the wrong tool for the job. If you vibe well with a language, and you achieve good LLM-sympathy with it, you'll be able to go farther than using a "right tool" you don't like.
IIUC, all i need to do next is pick one of these? fizzbee, tla, spin, alloy, ivy, quint, isabelle, lean, p language, dafny, coq, uppaal
28
57
5
357
17,769
Winkle retweeted
Software is having its Industrial Revolution and it’s changing what matters in software frameworks. Today’s frameworks were designed for the crafty carpenter, tomorrow’s are designed for mass manufacturing processes where rigor > conciseness. Take foldkit vs react/solid, for example. You can argue that foldkit is more verbose or complicated for some use cases compared to the traditional alternatives, but everything doable in react/solid is also doable in foldkit. Everything doable in foldkit is not (or at least not easily or consistently) doable in react/solid because they lack the rigor of command+event state machines with story & scene testing. Getting that back isn’t easy and is a substantial loss for agentic coding. Before AI, there was the valid argument of picking what humans like best. Humans kinda suck at programming because we are constrained by our skills, taste and (lack of) discipline, so frameworks that worked in this era catered to the lowest common denominator of mass market human developers. While I agree that react/solid are powerful in the hands of humans, that simply doesn’t matter anymore. What’s best for humans does not necessarily translate to what’s best for agents. Some tasks may indeed be “a bit harder” with foldkit in human terms, but AI is capable of solving all of them in a few minutes, so who cares. Instead of bike-shedding philosophy and taste, just choose the more rigorous (and scalable) option. It costs you nothing and gains you everything. Effect is another example of this. With AI, now everyone of all skill levels can use advanced programming techniques that are objectively safer and more scalable, but were out of reach for many human programmers. Or didn’t appeal to the stubborn tastes of a particular person. With humans now out of the way of technology adoption - I think it’s obvious that the following techniques are going to become way more commonplace: 1. State Machines 2. Functional programming 3. Declarative infrastructure 4. Test Driven Development 5. Domain Driven Design 6. Actor Systems 7. Rigorous API schemas 8. Type Safety and Formal Verification 9. Disciplined Operations (monitoring, on-call) Alchemy is designed to bring these techniques together into a seamless experience for building and deploying applications of massive scale. It is the “rails” and “parts” of the ai software assembly line.
29
42
18
693
54,375
Surprising results from @OpenAI 's new Terra release. It shouldn't be this good! Also separately, adding Clef into the benchmark reveals a new Pareto frontier: decisions are a very cost effective pathway for physical world understanding! (work led by @PerraultAndrew )
Thank you for confirming this! We are seeing the same thing with RealityBench. Still behind on our acceptability metrics, but very surprised to see Argon / Fable / Astra performance at such a strong price point. relantic.com/realitybench
2
3
2
8
806
Just spent the last 7 days on the front lines of the vulnpocalypse fending off an active cyber attack on one of our products. Some thoughts: - Software factories are going to be required equipment for everyone. There’s just no way to keep up with the pace of highly automated adversaries without one. - We were lucky because we had spent the last few months getting our software factory running well. It is nice to have for product development but proved to be absolutely essential this week. - At the minimum you need to have a coding server in the cloud pre-provisioned with read only access to all your logs and all the services you depend on for observability. With that in place you are a prompt away from reasonably good situational awareness, ongoing monitoring with loops, and ability for coding agents to validate fixes against your actual, observed attack patterns. - Shared coding server also unlocks multiplayer incident response where everyone can see every session and jump in as needed. Sharing session links that can be forked is much higher bandwidth than re-explaining things. - You don’t need to be Ramp/Stripe/Uber scale to have a working software factory in the cloud. We are a team of 3. Ours is built with an @opencode server (thanks @thdxr!), a forked version of compound engineering optimized for automated workflows (thanks @kieranklaassen!) and a multiplayer agent in slack that handles crons (we have our own harness but pick your favorite here). - To get our software factory up and running well, we had to stop all new product development for ~6 weeks and just focus on getting the validation systems working that enabled us to reliably shipping PR without human code review. This felt very painful in the moment but was totally worth the eventual speedup in velocity. - KYC for @AnthropicAI & @OpenAI cyber programs is now easy and quick (at least for defensive access), but a day felt like a lifetime this week. Submit your app now before you really need it. - Getting Mythos access unlocked a deeper level of analysis that helped us shift from reactive mitigation to proactive patching. Wish we had done this a few weeks earlier. Get started now!
72
155
59
1,874
263,307
In May 2025 we tried a simple idea to make Claude Code more useful for our non-technical teammates. We called it Skills. Turns out folders go a long way. Today Skills joins @AgenticAIFdn. Thank you to everyone who made agents a bit more useful for yourself and others <3
We're donating Agent Skills to the Agentic AI Foundation (@AgenticAIFdn), the same foundation we donated MCP to. Since December 2025, 70+ agent platforms have integrated the standard, including ChatGPT, Cursor, GitHub Copilot, and VS Code. Here's what that means for you:
5
2
23
2,313