Taimoor - πŸ¦€πŸ‘¨β€πŸ’» (@ich_code) header
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» (@ich_code) profile picture

IoT, Embedded and Renewable enthusiast! Systems Architecture is my passion. https://www.teapawt.org/t.co/zDZT8LFR0c

Germany
Joined December 2015
Photo by Taimoor - πŸ¦€πŸ‘¨β€πŸ’» (@ich_code)Photo by Taimoor - πŸ¦€πŸ‘¨β€πŸ’» (@ich_code)Photo by Taimoor - πŸ¦€πŸ‘¨β€πŸ’» (@ich_code)Photo by Taimoor - πŸ¦€πŸ‘¨β€πŸ’» (@ich_code)
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
IndexDB isn't cutting it anymore. We've been working on a new client-side database written in Rust using OPFS for our next sync engine in @linear. It indexes everything. As a drop-in, API-compatible replacement it's faster than IndexDB (which is surprising!), but it absolutely DESTROYS it when you do complex, multi-key queries. And while IndexDB queries slow down linearly as row count increases, our new database stays almost flat. It's like 600x faster with usage we see in Linear, more if you got to large workspaces. We do want to open-source it, but we can't before we decide on the name. We've got two strong candidates: - postindex - sub-linear Which one do you like more?
134
45
15
1,214
58,933
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
I've been exploring new ways to sandbox code written by coding agents - here's a description of the external sandbox pattern, where agents run on your Mac but execute code in a WebAssembly or QEMU or Apple Container sandbox - with demos for Claude Code, Codex and Pi blog.primeradiant.com/extern…
390
107
69
1,227
74,374
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
Replying to @RayFernando1337
I wish i could tag a principal engineer working at Intel (idk if he's on X). But we worked on a problem of runtime verification. Now it's not exactly the same problem poteto is talking about, but it's about constraints!! github.com/IndustryFusion/Di…
1
251
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
Sandboxes are the iFrames of agent execution. Untrusted execution, loosely integrated, isolated, and separate. Just like iFrames, agent sandboxes represent one of the coarsest forms of integration between the container (the harness or orchestrator) and the agent. I believe that in order to achieve true AI composability, we’ll need to see a shift toward native agents that are deeply integrated with agent runtimes, with a much more fine-grained approach to agent and model execution, permissions, isolation, and security. Sandboxes will remain important for executing untrusted operations, but they shouldn’t be the primary abstraction for composing AI applications.
13
2
3
58
3,560
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
I came to the conclusion that most SaaS should become an MCP server. we’re getting the economics of AI software backwards. A lot of AI startups are building their own chat interfaces, agents, and workflows, essentially reselling tokens from the big labs at low to negative gross margins. What if SaaS companies did the opposite? Take HR software. Instead of building an AI assistant, become the best MCP server for HR. Expose tools to: - Benchmark salaries against proprietary market data - Run compensation reviews and calculate pay equity - Model salary increases against a department’s budget - Recommend promotions based on company policies - Update employee compensation in the HRIS - Manage approvals, permissions, and audit trails Let ChatGPT, Claude, or Copilot handle the conversation, reasoning, and orchestration. Let the customer pay for the tokens. The SaaS company keeps the valuable stuff: proprietary data, integrations, business logic, permissions, compliance, and the system of record. You still charge a SaaS subscription, but you’re no longer paying to generate every answer. You can ship faster, with fewer engineers, and potentially restore software-like gross margins. The next generation of SaaS might not have much of a UI at all. Just an incredibly good MCP server.
365
157
105
2,093
213,244
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
How to turn slop into gold. Super concrete steps from awesome @poteto on making coding agents trustworthy: 1. Clean up the code your agents learn from. Your codebase is one of their biggest inputs. Agents copy whatever looks like an established pattern, including workarounds, deprecated code, and yesterday’s questionable decisions. Clean those up, or watch them reproduce. 2. Turn corrections into enforceable checks. Every time you correct an agent, ask: can this become a lint rule, a type constraint, a test, or a better API? Put the correction somewhere the system can enforce it. A growing AGENTS.md still requires the agent to follow every instruction. 3. Remove opportunities for predictable mistakes. Her team @SpaceXSI restricts React’s useEffect to framework internals because agents repeatedly misuse it in product code. They also enforce import boundaries between application processes. These constraints eliminate whole categories of mistakes that would otherwise keep coming back in review. 4. Give agents a reliable way to run and inspect the product. Provide debugging tools, reusable CLIs, and a β€œfeature map” describing the application from the user’s perspective. Now β€œthat thing in the left sidebar” has a shared meaning, and each agent can reuse the tools for checking it. 5. Review evidence of behavior. Have agents produce screenshots, videos, and state diagrams. These help you check what the product actually does and how closely that matches your intent. A convincing explanation of a fix is easy to generate; seeing the fix work is considerably more useful. 6. Spend serious effort on verification. Her team uses runtime verification and is experimenting with property-based UI testing and formal methods, including TLA+ model checking. Lauren says most of her token usage goes toward verification. Agents make some previously expensive testing work much more practical. 7. Automate once that loop is reliable. Her team now has agents exercise new releases, find bugs, open fixes, and merge them automatically. Getting to that level of trust took her about six months of investing in the environment. The results she reports: 11,000 pull requests shipped by her team in a month, a revert rate around 0.5%, and improvements in startup, typing, and switching chats. And what about infamous β€œsoftware factory”? if your coding loop produces slop, automating it produces more slop, faster, with a larger token bill. Start by making good code the easiest thing for an agent to produce. Then scale it. As always, content at @aiDotEngineer is gold πŸ†
50
165
15
2,406
165,833
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
At the same time as the Intercom platform being massively stabilised, this is the open bug count for our helpdesk.
This is from our October internal availability report. We're far from perfect, but we're doing well. The biggest contributor to this is our MySQL databases being hosted on PlanetScale. Also, no sign of our AI acceleration causing serious problems.
3
4
3
47
3,336
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
AWS Emulator is here! Building API emulators has been huge for Amazon teams this year. We let agents run against dependencies over and over in a feedback loop, all in the local env. The most popular one internally emulates AWS APIs: it's 100% built by agents and now open source. Software factory: aboutamazon.com/news/aws/how… Blog: aws.amazon.com/blogs/aws-ins… Source code: github.com/aws/aws-emulator Evals: github.com/aws/aws-emulator-… User guide: docs.aws.amazon.com/emulator…
25
54
11
351
28,575
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
Fresh data confirms what I shared back in April: native mobile and frontend roles are dying. This trend sped up. Safe to assume the only devs getting such jobs are very experienced ones. You need to become a more general software engineer with AI, to have career stability.
Engineering is changing: FDE is ascendant while mobile and front-end roles are disappearing. Open mobile and front-end engineers jobs have been nearly halved in the past year!
159
115
42
1,787
151,507
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
So bullish on MCP. Its utility exceeds the "M" part: even AI aside, it'll be a civilization-scale accomplishment to get all our systems communicating through one universal open protocol. A missing piece was how to get arbitrary callbacks across sessions. MCP could read and write, but it couldn't tell you later "this event happened." MCP Events fixes this. We're adding support in our own MCP. Say an agent makes a deployment, and wants to know when it's complete. Instead of polling, it can subscribe to πšπšŽπš™πš•πš˜πš’πš–πšŽπš—πš.𝚜𝚞𝚌𝚌𝚎𝚎𝚍𝚎𝚍. PSA: With Vercel Queues and Workflows, writing the backend machinery for your own MCPs to do this is easy peasy.
Vercel MCP now publishes events. Agents can subscribe to events like πšπšŽπš™πš•πš˜πš’πš–πšŽπš—πš.𝚜𝚞𝚌𝚌𝚎𝚎𝚍𝚎𝚍 and πšπšŽπš™πš•πš˜πš’πš–πšŽπš—πš.πšŽπš›πš›πš˜πš› and get webhook notifications when they fire. No more polling for changes. Changelog β†’ vercel.com/changelog/vercel-…
169
64
20
1,070
89,694
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
Loose thoughts on the future of abstractions: At first glance, it seems evident that shared abstractions (stdlibs, frameworks, libraries) will still be beneficial in a world of agents. Centralized and shared knowledge, lower costs (no tokens needed) are just two reasons for why this is good. But, looking back at the last ten years, it's clear that a lot of frameworks and libraries were made due to (to simplify) personal preference: framework X is Y but in language Foo which has same runtime characteristics as Bar but I like it better, or framework X was born out of frustration with syntax of Y, or framework X uses TOML instead of YAML and is container-native or ... <insert favorite thing here>. Meaning: a lot of abstractions in the last twenty years were made for reasons that no longer seem valid. That makes me think that there will be less need for more abstractions (as we've known them!) in the future. But if you look around, you'll see that there's a thousand new things being created every day. I think that's a temporary phase. There are other, deeper (for lack of a better term) abstractions though that still seem valid: abstractions that introduce a different way to compute. Think: type systems, Lisps, CUDA, unikernels, IaC, k8s. (That's not a final and super confident list, more a general pointing in a direction. I'm unsure here.) I do think that in the future people will still create new abstractions of this latter type. Sharing those is still valuable, because they go along with a platform or a product. But the former type -- different languages that just switch syntax, frameworks that fix one grievance, util-like stdlibs -- for that I can see a future in which we're just endlessly remixing and "vendoring" existing abstractions. And just to say this out loud: I do think a lot of code-level abstractions (MVC, composition over inheritance, avoid-god-objects, classes vs. modules) don't matter in the future, because they're born out of the ability of humans to understand and maintain code. Even if new abstractions in this realm might make sense in the future, I think the barrier for them to spread is now incredibly high. Example: friend reported that in his company they're trying to introduce a new pattern because "adding a new country to our system requires changing all of these places in this 1500-line long class" -- who gives a shit about that anymore? Oh and another thing: I think the "is it in the training data?" concern is way overblown by now. Intelligence generalizes to a certain degree and the latest models have 0 problems writing in a language or framework that you just made up. Try it.
35
9
5
190
12,777
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
we are entering a renaissance in programming language and runtime research, and a golden age of software testing and verification it’s time to rewrite all software
536
671
188
10,231
481,181
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
After a week of talking with folks writing software (and/or building infrastructure, or doing security, or running corp apps) - it’s crystal clear to me that we’ve got two things to do: 1) We need to help folks experience how to build systems with AI that actually work. The jump from β€œI use Claude/codex/cursor” to β€œwe are building the machine that builds the machine” (or a software factory, if you want) is big, and what engineers actually need isn’t a product that hides the jump - they need to experience how straightforward it can be to engineer it. 2) We have to trust that they know better than we do how to build the software they build. It’s easy in the technology bubble to take pot-shots (and it’s so common that the most normal beginning of a conversation I have with engineers is some variant of an apology for how behind the times they are) - but everyone I know whose having success building in this era is having it because they built that system to fit the product and team they work on. AI didn’t replace software engineering, and it won’t make it obsolete. What it’s done is altered the range of possibilities on how to produce good outcomes in ways that are very hard to see without experiencing them. As an industry we’ve done this before - it’s just never been quite as fundamental to software developers. For example, I taught a lot of folks how to run CD and rethink their product process due to the acceleration from cloud and social. Every single one of those also taught me something new about how to do it. The stage we are at isn’t certainty of approach. It’s of weird, messy experimentation, coupled with public conversation about what’s worked and what doesn’t. We have to teach each other. Call it software factories. Call it agentic development. Call it harness engineering. Call it schmoopy pants. I don’t care. But tell me what works, and I’ll tell you what works, and together we will build the way to do it together. Less gate keeping, more creativity enablement.
27
15
1
82
4,773
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
hot take: you don't need a software factory, and i don't love the term. it's just marketing all you need is good software engineering and investing your tokens in the right places. the more deterministic the better (and token efficient)
all the companies selling you a software factory produce a shockingly tiny amount of software
439
585
181
8,143
515,428
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
No moat higher up in the stack, no moat lower, no moat in the middle.
11
6
86
10,971
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
On building scalable control planes allthingsdistributed.com/202…
1
12
1
187
17,033
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
IaC is dead. Sorry DevOps / SREs / Cloud Engineers but you're in for the same roller coaster as Devs. AI can manage infra change better than you. Unfortunately for IaC, we don't need code because with the actual system source code and the infra, AIs have everything needed to determine change sets / approvals and dev env lensing. btw, Effect Oriented Programming probably will help you get there; but that is inevitable for your codebase.
134
68
66
718
255,413
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
We are building AX to be a Kubernetes for agents to be able to manage other agents. Our assumption is workloads will be provisioned and managed primarily via other agents not by humans. Agentic loop is the new job controller loop.
38
24
5
358
35,863
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
I've just finished filming the most ambitious course of my career. It starts November 9th, and runs for 2 weeks. It's everything you need to build your company's software factory. Everyone's talking about how to go FASTER with agents. That's really, really easy. Loops, YOLO mode, dark factory. That's a recipe for a slop cannon. No serious organisation is going to trust a factory like that. So, you need to slow down to speed up. What's the first pedal your driving instructor showed you? Not the accelerator. Once you put the brakes on your agent - to constrain it and increase its output quality - you can start to trust it. The best brakes? Good ol' software fundamentals. Here's what we cover: - Automated Review - Codebase Design - DDD & Ubiquitous Language - Mutation Testing - Feedback Loops From there, the course accelerates. We show you a working factory and build your system design skills. We even plan your infra with you. You'll walk out with a software factory spec, ready to hand to an agent. And you won't be learning alone. You'll have a massive community with you, learning along. We actually opened sales on Monday. It's already on track to be BY FAR the biggest course of my career. Want to join in? Here's the link below: aihero.dev/s/wS5YtK
79
92
13
1,684
154,519
Taimoor - πŸ¦€πŸ‘¨β€πŸ’» retweeted
What I want to know from the 5 new CI and sandbox providers I see every day spruiking how they are x% cheaper than everyone else: What are your margins like? If you're a thin wrapper around someone else's compute, what is your actual plan to retain folks when the next provider undercuts you? How can you convince customers you'll actually be here in 12 months and won't go broke or lose their data?
11
3
2
49
9,096