Amit Bahree 🌏💾

🚀Unlock the Future with #GenerativeAI! I'm thrilled to announce my new book, Generative AI in Action, published by @ManningBooks is now available in print! 📚mng.bz/E9Aq Dive deep into Generative #AI, #LLMs, and more to transform your business. (1/2)

So true. I should now put the box down.

📣Meet Qwen3.7-Max — our latest flagship, made for the Agent Era. A versatile foundation for agents that actually get things done: 🧑‍💻 Coding agent, end to end. Frontend prototypes, multi-file refactors, real debugging — nails it. 🗂️ A reliable office and productivity assistant. Get your work done through MCP integrations and multi-agent orchestration. ⏱️ Long-horizon autonomy. 35 hours straight on a kernel optimization task — 1,000+ tool calls, zero hand-holding. 🔌 Scaffold-agnostic. Claude Code, OpenClaw, Qwen Code, or your own stack. Consistent reliability everywhere. API's up on Alibaba Model Studio. You can also take it for a spin on Qwen Studio. Go build something wild!🏃🏃‍♂️ 📖 Blog: qwen.ai/blog?id=qwen3.7 ✅ Qwen Studio: chat.qwen.ai/?models=qwen3.… ⚡️ API：modelstudio.console.alibabacloud.com/ap-southeast-1…

The Navy rejected her for being too old and too thin—so she invented the code that still runs your bank account, and became an Admiral. In 1943, Grace Hopper was 37 years old with a PhD in mathematics from Yale when she tried to enlist in the U.S. Navy during World War II. They turned her down. She exceeded the age limit by two years. She was 15 pounds underweight. And she was a woman trying to work with military technology—something the Navy didn't believe women could handle. Grace found another way in through the WAVES program and received a waiver. They gave her a uniform and assigned her to an impossible challenge: the Harvard Mark I computer. It was 1944. The Mark I filled an entire room, weighed 5 tons, contained 750,000 mechanical parts, and made strange clanking sounds as it calculated artillery trajectories. Few people understood how it worked. Even fewer believed a woman could master it. Grace Hopper didn't just master it—she taught it to speak English. THE REVOLUTIONARY IDEA In the 1940s and 1950s, programming meant writing in machine code—endless strings of ones and zeros that only computers understood. It was tedious, error-prone, and required programmers to think like machines. Grace thought that was backward. "Why should humans have to speak the computer's language?" she asked. "Why can't we teach computers to understand ours?" The computing establishment told her it was impossible. Computers could only process numbers. They could never understand words or human language. You were wasting your time even trying. In 1952, Grace proved them spectacularly wrong. She invented the first compiler—a program that could translate human-readable instructions into machine code. She called it the A-0 System, and it was revolutionary. "Nobody believed it," she recalled years later. "I had a running compiler and nobody would touch it. They told me computers could only do arithmetic." But Grace kept pushing. Her compiler evolved into something even more transformative. THE LANGUAGE THAT RUNS THE WORLD By the late 1950s, Grace was leading the team developing COBOL—Common Business-Oriented Language. COBOL was designed to be readable by non-programmers. Instead of cryptic symbols, it used actual English words: READ, WRITE, COMPUTE, ADD. For the first time, business people could understand what a program did just by reading it. The programming elite dismissed it. It was too simple. Too English. Real programmers didn't need "readable" code. COBOL became the most widely used business programming language in history. Today—right now, as you're reading this—COBOL still processes: 95% of ATM transactions 80% of in-person credit and debit purchases Most airline reservations Major credit card systems Social Security payments Trillions of dollars in daily financial transactions The code Grace championed in the 1950s is still running the world's financial infrastructure seventy years later. THE MOTH In 1947, Grace was debugging the Mark II computer when it malfunctioned. Her team opened it up and found a moth trapped in Relay #70. Grace carefully taped the moth into the logbook with the notation: "First actual case of bug being found." That moth is still preserved at the Smithsonian. Grace didn't invent the term "bug"—engineers had used it for decades. But she loved the story because it perfectly captured her philosophy: Find the problem. Fix it. Document it. Move forward. THE NANOSECOND Grace remained in the Navy for decades, becoming one of its most respected officers. She became famous for a teaching technique that made the abstract concrete. She carried pieces of wire exactly 11.8 inches long—the distance light travels in one nanosecond, one-billionth of a second. She'd hand them to generals and admirals and say: "This is how far your signal travels in one nanosecond. Now you understand why satellite communications have delays." Then she'd show them a coil of wire nearly 1,000 feet long—one microsecond. "This is why you can't waste time," she'd say. It was brilliant. She made the invisible visible. She made the incomprehensible concrete. She turned abstract computer science into something you could hold in your hand. THE ADMIRAL Grace was recalled from retirement multiple times because the Navy desperately needed her expertise. Each time, she said yes. She finally retired in 1986 at age 79—the oldest active-duty commissioned officer in the United States Navy. By then, she was Rear Admiral Grace Hopper. She'd received the Defense Distinguished Service Medal and over 40 honorary degrees. She'd been inducted into the National Women's Hall of Fame. In her final interviews, she wore her uniform with sharp precision and still handed out those nanosecond wires. "You have no excuse to be slow," she'd say with a smile. THE LEGACY Grace Hopper died on New Year's Day 1992 at age 85. The Navy named a destroyer after her: USS Hopper (DDG-70). Yale named a supercomputer in her honor. Google named a building after her. Microsoft created the Grace Hopper Celebration—the world's largest gathering of women in technology. But her real legacy is something you experience every single day. Every time you use a computer and it understands what you want, you're using Grace Hopper's vision. Every time you read code that makes sense, you're reading in the language she championed. Every time you debug a program, you're using the process she helped define. She was told computers were too complicated for women. She was told humans couldn't make computers understand English. She was told she was too old to serve her country. She proved them all catastrophically wrong. Grace Hopper didn't just program computers. She programmed the future. She proved that technology should serve humans, not the other way around. She showed that the best code is code people can understand. She demonstrated that age means nothing when you have vision and determination. They called her "Amazing Grace." She preferred Admiral. Every time you withdraw cash from an ATM, swipe a credit card, book a flight, or use a computer that speaks your language instead of binary code—you're standing on her foundation. Rear Admiral Grace Hopper (1906-1992): The woman who taught computers to speak English and changed the world forever. "The most dangerous phrase in the language is, 'We've always done it this way.'" — Grace Hopper She never did things the old way. And we're all better for it.

@matvelloso +1 - the field is the MSFTs FDE and has been for decades. That really is the muscle.

In the first half of my career I was a consultant doing work for large enterprises, mostly with Microsoft technologies. Looking back, I think this was one of the pillars of Microsoft's incredible penetration across the large enterprises: There were armies of people spending time, listening, understanding business goals and solving them with technology in every industry vertical. It is interesting to see AI labs doing this now. Same recipe and same problem to be solved: The value of the tech multiplies once you have people who know how to use it well spending time with each customer and working on things with well defined goals/outcomes. (you can call it consulting, post sales, forward deployment, field engineering, etc. To me it's all flavors of the same thing). What this shows is that the AI labs aren't happy delegating it to hyperscalers anymore, they want to cut the middleman and own that relationship themselves.

@linasbeliunas @OpenAI Its consulting in a new bottle - same wine 🍷.

@OpenAI So both OpenAI & Anthropic have now outsourced their sales teams to PE 👀 This is basically Palantir's FDE playbook on steroids. Full breakdown here: linas.substack.com/p/weeklyfintec…

Today we’re launching the OpenAI Deployment Company to help businesses build and deploy AI. It's majority-owned and controlled by OpenAI. It brings together 19 leading investment firms, consultancies, and system integrators to help organizations deploy frontier AI to production for business impact. openai.com/index/openai-l…

@ferby_Dstampede @OpenAI @Dimillian More like the big consulting folks like Accenture, TCS, Cap, etc.

@OpenAI @Dimillian Watch out Big 4!

How many penalties would Hamilton get for this today? 💀

@aarnott I has forgotten about .Net CF.

Today I'm celebrating my 20-year work anniversary at Microsoft. 🥳👏🏼 Microsoft has been great to work for. Company level and all my managers and coworkers have been a delight to work with. In my tenure I've worked on .NET Compact Framework, the .NET immutable collections, Visual Studio's project system, VS's threading library, VS-MEF, an entire RPC stack, the C# Dev Kit extension for VS Code, and of course much more. I also worked on several very exciting projects that never shipped. 🪦

@ihtesham2005 Is there a tldr?

A Stanford computer science professor has been teaching the same software design class for more than a decade, and every quarter the seats fill faster than almost any other course in the department. Students from Google, Meta, and Apple sneak back onto campus to audit it. Most of them have been writing code professionally for years. I read the book that came out of the class in a week and walked away seeing every codebase I had ever worked on through completely different eyes. His name is John Ousterhout. The book is called A Philosophy of Software Design. Almost everyone in tech eventually hits the same wall. You learn to code. You get good at it. You ship features. 6 months in, you cannot find anything in your own codebase. 12 months in, you are afraid to change things. 2 years in, you start wondering if the problem is you, because everyone around you seems to be drowning at exactly the same depth and nobody is willing to admit it. Ousterhout's argument is that the problem is not you. The problem is that nobody ever taught you what software was supposed to look like. Here is the story almost nobody tells you. Ousterhout was already a legend before he became a teacher. He invented the Tcl programming language, which has been used inside everything from Cisco routers to NASA spacecraft. He built systems companies. He served as a senior fellow at Electric Cloud and as VP of research at Sun Microsystems. By any normal measure he had earned the right to coast. He went back to Stanford instead. The reason he gave in interviews is the part that should make every senior engineer pay attention. He said almost every brilliant engineer he had hired in 30 years of running teams had the same gap. They could implement anything. They could solve any algorithmic problem. They could ship code that compiled, ran, and passed tests. And then 6 months later their own code would start to suffocate them, and they had no idea why. Nobody had ever taught them what good software was supposed to feel like to maintain. Universities taught data structures and algorithms. Bootcamps taught syntax and frameworks. Companies taught company processes. But the actual craft of designing software so that you would not hate yourself in two years was being passed down by accident, in code reviews, by the few senior engineers who had figured it out the hard way. Ousterhout decided to teach it on purpose. He built a class called CS 190 at Stanford, A Philosophy of Software Design. The structure of the class was unusual. Students did not just write code. They wrote code, threw it away, and rewrote it from scratch after detailed feedback. Sometimes 3 rewrites per assignment. The point was not to ship a project. The point was to feel, in your own hands, the difference between a system designed well and a system designed badly. Most students had never felt the difference before. After the class, they could not stop seeing it. He turned the lectures into a small book. It is around 190 pages. The first edition came out in 2018. It costs less than a textbook. It has quietly become one of the most-shared engineering books inside senior teams at Google, Meta, Stripe, OpenAI, and Anthropic. Senior engineers buy copies for their juniors. Tech leads send specific chapters to their teams during code reviews. The argument inside the book is brutally simple. Complexity is the enemy. Not bugs. Not slow performance. Not missed deadlines. Complexity. A system too complex to hold in your head is a system you will break by accident. You will not know which line broke it. You will fix the symptom and miss the cause. Over time, complexity compounds. The codebase becomes a place engineers fear to touch. New features take longer. Old features break for unrelated reasons. Eventually the team starts whispering about a rewrite. The rewrite usually fails for the same reasons the original did. Ousterhout argues that complexity comes from two sources. Dependencies, which are pieces of the system that affect each other across boundaries. And obscurity, which is information about the system that you cannot see from where you are reading. Reduce one, you almost always reduce the other. The deepest insight in the book is about what good modules actually look like. Most engineers are taught to build small, simple modules with lots of small, simple methods. Ousterhout calls these shallow modules and he says they are the disease, not the cure. A shallow module has a small interface and an even smaller body. The interface barely hides anything. To use the module, you have to understand almost everything inside it. Building software out of shallow modules creates the illusion of organization while the actual complexity stays exposed. Good modules are deep. A deep module has a small interface that hides a large amount of functionality inside. You use the module without understanding how it works internally. The interface gives you exactly what you need and nothing else. The complexity is contained. Files have file names, sizes, modification dates. You read and write them. You do not need to know about disk sectors, file allocation tables, or buffering strategies. The Unix file system is a deep module. Most modern abstractions are not. This is the part of the book that makes engineers stop reading and look at their own code with horror. Most production codebases are full of shallow modules disguised as good engineering. Tiny classes. Tiny functions. Long parameter lists. Wrapper layers that wrap other wrapper layers. Every layer leaks information about the layer below it. Every interface forces the caller to understand internals. Engineers wrote it that way because they thought small was good. Ousterhout argues that small is not good. Hidden complexity is good. The module should be doing a lot. The interface should be revealing very little. The second insight that landed hardest for me was about comments. Most engineers are taught that good code does not need comments. The code should be self-documenting. Variable names should be descriptive. Functions should be small enough to read top to bottom. Comments are a sign of failure. Ousterhout argues this is wrong, and that the people who say it have never actually maintained a large system over many years. Comments are not a failure of the code. Comments are how you write down the things the code cannot say. Why a particular approach was chosen. Why a tempting alternative was rejected. What invariants the function depends on. What the caller is supposed to know. None of these things can be expressed in code itself. If a future reader has to read every line of your function to understand what it is doing, you have not finished writing it. The job is not done when the tests pass. The job is done when the next engineer can pick up the file and understand it without asking you a question. The third insight is the one that hit me hardest, because it is the one almost no engineer is taught to think about until it is too late. Strategic versus tactical programming. Most engineers are taught to be tactical. You get a task. You finish the task. You move on. You take the shortest path between the current state of the codebase and the new feature. Each individual decision is reasonable. The combined effect, over years, is a codebase that has been hacked into shape by hundreds of small reasonable decisions, none of which made the system better as a whole. Strategic programming is the discipline of asking, every time you make a change, whether the change is leaving the system better than you found it. Sometimes the smallest task should pay for a refactor that makes the next ten tasks easier. Sometimes the right move is to pause for an hour and redesign the abstraction before you add the feature. Tactical programmers always feel like they are moving fast. Strategic programmers actually move fast. The difference becomes obvious around the two-year mark. Ousterhout's rule is the one I think about almost every day now. The best engineers do not write code faster than bad engineers. They delete code faster. Every line you add to a system is a permanent tax on every future reader. Most of the job of being a senior engineer is deciding what not to write. The book is short. Around 190 pages. You can finish it in a weekend. Reading it once will not make you a better engineer. Reading it twice, then watching yourself catch your own bad habits in real time, then forcing yourself to redesign one module per week using its principles, will measurably change how you write software in less than a year. Almost every engineering team I admire has at least one person who has read this book carefully and has been quietly nudging the rest of the team toward what it teaches. Most teams that do not have someone like this end up rewriting the same system every two years and never understanding why. Ousterhout is still teaching the class at Stanford. The course site is public. The book is around twenty dollars. The single most useful book about how to actually design software is sitting one click away from you. Most engineers will spend a decade learning the hard way what 190 pages would have taught them in a weekend.

@__apf__ @ATX_JS Surely you could have asked a agent or LLM for the said lacking psychic ability? 💀

@ATX_JS there were two cars parked there when I left. I lacked the psychic ability to predict the size of a future, larger car. to make it fit, I would have to pull up and put my nose 2' into a red curb. his car is successfully parked 20ft away in another empty spot in front of my house.

when I went out of town, I left my car parked in front of a mini cooper. I got back to a pile of notes from a man who prefers to park his Tesla on the street in front of my house instead of in front of his house, driveway, or garage. parking is not scarce. how should I respond?

@loomdoop @thegrugq I hardly think the Linux kernel is a outdated book.

Putting outdated coding books in the Little Free Library should be considered illegal dumping, and carry a sentence of 100 hours community service.

Benchmarked 8 large open #LLMs on a 16x #H200 cluster. Llama 4 Scout and MiniMax M2.1 led. 8x H200 beat 16x for most models. DeepSeek V4 Flash held up well on long-context. Full numbers + pipeline here 👇 blog.desigeek.com/post/2026/04/b… #LLM #vLLM #H200 #AI

@speeddying @sukh_saroy +1 And it was rightly debunked as a very constraint and poorly setup. Sukh you need to stop embarrassing yourself dude.

@sukh_saroy This is not breaking. This was in Nov 2025 arxiv.org/pdf/2506.06941

🚨BREAKING: Apple just dropped a paper proving the smartest "reasoning" AI models on Earth don't actually reason. They collapse to 0% accuracy on a puzzle a 7-year-old can solve. The way they proved it is brutal.

@LurkAtHomeMom Some of us are proud to be born that way / don't need no stinking keyb. PS - I like SwiftKey

Shout out to the iPhone keyboard for making it look like I’ve lost my god damn mind.

@migueldeicaza I mean what can we do. The other thing ain't like it doesn't deserve it.

There is no easy way to say this. But I am putting Claude on a PIP.

yo @OpenAI , @sama this #codex is getting dumber and dumber - down to my level - and that's not a compliment. #Agents meh!

@gkisokay Got tips for me?

The Local LLM Cheat Sheet for your 32GB RAM device I was asked to put together a practical lineup of local models that fit comfortably on a 32GB machine. At this tier, you start getting access to real flagship-class local models, plus a growing number of custom quants. But for most people, these are the core models worth knowing first. Flagship Models Qwen3.5 27B / GGUF / Q6_K_M The best overall 32GB flagship. General chat, writing, research, and agent workflows. Great if you want one model that can handle almost everything well. Qwen3.6-35B-A3B / GGUF / UD-Q4_K_M Best MoE flagship. Stronger for coding, reasoning, and tool use than most smaller generalists. Gemma 4 31B / GGUF / Q6_K_M Dense premium model. Writing, analysis, reasoning, and high-end local chat. Heavier than the MoE options, but excellent when quality matters more than speed. Models for Fast Flagship Use Gemma 4 26B A4B / GGUF / Q6_K_M Great balance of speed and quality for general assistant work, coding, agent tasks, and research. This is one of the best 32GB picks if you want something that feels high-end without dragging. DeepSeek-R1 Distill Qwen 32B / GGUF / Q4_K_M Offline reasoning engine. Best for math, logic, deliberate analysis, and step-by-step problem solving. Mistral Small 24B / GGUF / Q6_K_M Tool-calling specialist. Strong for assistants, chat workflows, local business tasks, and function calling. Available for 24GB machines. Models for Companion Use Qwen3.5 9B / GGUF / Q6_K_M Best sidekick. Fast drafts, search loops, cheap retries, and secondary agent work. Even on a 32GB machine, you still want a smaller model around for support tasks. Llama 3.1 8B / GGUF / Q6_K_M Long-context companion. RAG, doc ingestion, codebase chat, and long prompts. The output quality is not the sharpest anymore, but it is still useful when needing simple tasks fast. From what my community tells me, the best single models are Qwen3.5 27B or Gemma 4 31B. For two models, the strongest general pairing is Qwen3.5 27B + Qwen3.5 9B. If you are more code-heavy, Qwen3.6-35B-A3B + Llama 3.1 8B. Let me know what models you are running on 32GB, and which ones have actually been worth the RAM.

I got completely owned by the most sophisticated hack I've ever encountered. I'm a developer. I know what scams look like. This didn't look like one. 🧵

Anthropic said Mythos was too dangerous to release. Then four random guys in a Discord gained access on day one by guessing the URL... This is pretty insane: → Group in a private Discord guessed the endpoint from Anthropic's naming conventions → They figured out the conventions from the leak in the Mercor breach three weeks ago → Used a contractor's legit eval credentials to walk in → Have been using it ever since to build simple websites The AI that finds zero-days in every operating system on earth was defeated by address bar autocomplete... big yikes