You just have to know where to look on the Steam page.

The Earth may not be that massive, but it still distorts space-time.

Dumb Co sells flip phones that sync to your smartphone, bridging the infinite connectivity of the iPhone and the unrealistic limitations of an early 2000s relic.

How migrating Copilot code review to shared Unix-style code exploration tools reduced review cost by reshaping agent workflows around pull request evidence. The post Better tools made Copilot code review worse. Here’s how we actually improved it. appeared first on The GitHub Blog .

If you were to look up into the night sky, what would you see? Countless points of light, scattered in every direction. Most of what you're looking at are stars. But some of those points are whole galaxies—vast collections of stars, spread across incomprehensible distances, compressed by that distance into a single pinprick of light. And what you can see with the naked eye is only a small fraction of what's actually out there. I want to use this as a way to offer you a way of thinking about how large language models work. Just an analogy, not literally what's happening inside the mathematics—that's not my forte. My hope is that it captures something true about the mechanics, and more importantly, it gives you a mental model you can actually use when you're working with these systems. About two years ago, I was wrestling with finding a way of explaining what an LLM does. My first analogy was that of a dictionary. The naive view was that a dictionary uses words to define other words, and an LLM holds a matrix of words with weights that describe their relationships to each other. So the parallel seemed natural: both systems work through relational structure. However, a dictionary gives you denotation—the surface-level meaning. It's a lookup tool for individual words, not a model of language itself. And critically, you have to already understand language before a dictionary is useful to you at all. The analogy didn't capture what was actually happening in the weight relationships—the distributional semantics, the contextual patterns that let an LLM generate coherent text. Ok, so back to galaxies, when you look up at the night sky, you're not seeing distance—you're seeing direction. That galaxy over there, the one that looks like a point of light, could be millions of light-years away, but what matters for our analogy isn't how far it is. It's which way you're looking. And when you point yourself in that direction and venture toward it, you discover it's not a point at a

Note: Google Cloud credits are provided for this project. In this blog post, I want to demonstrate how I use Antigravity CLI to build an image analysis demo using Angular, Firebase Hybrid & On-device Inference Web SDK, and Gemini models. Users upload an image and use a Gemini model to analyze it to generate a few alternative texts, tags, recommendations, and CSS tips to enhance the image quality. When the demo is running on Chrome 148+, the Hybrid & On-device SDK leverages the Prompt API of the on-device Gemini Nano model to perform the image-to-text tasks, and the token usage is 0. When other browsers such as Safari or Firefox executes the same tasks on the demo, the SDK falls back to Cloud AI (Gemini 3.5 Flash model), and the token usage is greater than 0. Next, I will describe how I installed the skills in my Angular project, and registered the Stitch MCP server in the Antigravity CLI to develop the infrastructure, services, and UI design of my demo. 1. Skills I installed grill-with-docs , angular , and firebase skills in my project for the following reasons: grill-with-docs: Conduct a rigid Q&A session to generate a specification for a feature, refactor or a critical fix. AI is responsible for performing a thorough analysis and putting in more effort to generate code to achieve the task. Angular: Provide the best practices of Modern Angular architecture, such as using signals and signal forms. Firebase: Provide the skill for Firebase AI Logic, Firebase Remote, etc. Resources Firebase Hybrid & On-device Image Analysis App Firebase Hybrid & On-device Inference Chrome Built-in Prompt API Stitch Stitch MCP Server grill-with-docs Angular skill Firebase skill

Anthropic Built a Fix That Proves the Problem 🔍 Right, so Anthropic dropped Tool Search on November 24th alongside Claude Opus 4.5, and I need you to sit with the implications for a second because they're brutal for MCP. Tool Search lets you mark tools as defer_loading: true . When you do that, the tool's schema never enters your context window until Claude actually needs it. Claude gets a name and nothing else. When a task comes in that requires the tool, Claude calls the Tool Search tool, pulls the schema, and only then does it have the full definition loaded. Lazy loading for AI tools. Sounds boring. It's not. Here's the number that should make you spit your tea out: accuracy went from 49% to 74% on Opus 4. On Opus 4.5, it climbed from 79.5% to 88.1%. Same model. Same tools. The only difference is not loading the tool definitions upfront . I'll say it again. The mere presence of tool schemas in context was tanking accuracy by 25 percentage points. Twenty-five. Not because the model got confused by irrelevant tools (though it did). Because the context window was full of JSON nobody was using, and the model was drowning in it. This is an admission dressed up as a feature I've been banging on about MCP's context cost since July. The Playwright MCP server alone burns 12.8k tokens just sitting there. Load four or five MCP servers and you've torched half your context window before asking the model to do anything useful. Tool Search is Anthropic's answer. And the answer is: don't load the tools. Think about that for a second. The company that created MCP built a feature whose entire purpose is avoiding the cost of loading MCP tool definitions. If that isn't an admission that the protocol has a context problem, I don't know what is. They didn't say "we've made MCP more efficient." They said "here's a way to not load MCP schemas until the last possible moment." The fix is the diagnosis. And the timing is proper interesting. Three weeks earlier, on November 5th, mcporter d

The Man Behind the Minimalism I met Peter Steinberger at Claude Anonymous in London sometime in June, and the presentation was properly fun. He's got that energy where you can tell he's not performing, he's just genuinely excited about the stuff he's building. Maintains a 300k line TypeScript React ecosystem. Web app, Chrome extension, CLI tool, Tauri desktop client, Expo mobile app. All maintained by one person with AI agents. And his setup is basically: open 3-8 parallel Codex instances, write short prompts (often 1-2 sentences plus a screenshot), let them go. He calls everything else "charade." I've been following his work since and I reckon he's one of the most practical voices in the agentic coding space. No hype. No frameworks for the sake of frameworks. Just a bloke who ships a lot of code with AI and has opinions about how to do it well. His Principles (and Where I Stand) Here's the full list from his talk and blog posts. I agree with most of it. Where I don't, I'll say so. Things I violently agree with: Use tmux to run CLIs persistently. Absolutely. This is foundational. If you're not doing this, start here. Use ast-grep as a pre-commit hook. Proper structural linting that catches things regex can't. Brilliant addition to any agent workflow. Ask for options before executing. I built a whole /interview skill around this. Get the model to present choices rather than guessing. Way better outcomes. Don't reset context. Cold start wastes time + tokens. Agreed, but I'd go further. Don't reset, /handover instead. Summarise what was accomplished, carry it to the next session. Cold start is a waste. Context reset without transfer is nearly as bad. Give examples. Multi-shot prompting is always better than zero-shot. If you want the model to output something specific, show it what that looks like first. Massively improves one-shot accuracy. Use voice input. Absolutely. I started with Superwhisper and it changed how I work. Speaking your intent while pacing around the

What I'm Reading and Watching This Week 📚 [Article] " Deep Work in the Age of AI " by Cal Newport. Proper interesting take on how AI coding tools change our relationship with focused work. Made me rethink a few things about how I structure my own deep work blocks. [Video] "The Art of Code Review" by ThePrimeagen. Some good bits on making code reviews actually useful instead of the usual rubber-stamping faff. [Book] Currently reading "Staff Engineer" by Will Larson. If you're a senior dev wondering what comes next, this is the one. Side Projects and AI Dev Tools I'm Building 🛠️ stevengonsalvez.com 🟢 Active Next.js 15 + MDX blog platform with the byte-sized banter section you're reading right now. Foundation's done, blog section coming together. Next up is deploying to Vercel and sorting the domain. Personal MCP Server 🟡 On Hold Custom MCP server for personal productivity tools. Paused while I wait for Claude Desktop to get its MCP support properly sorted. What Changed This Week 🗞️ Migrated the blog from dev.to-only to a self-hosted Next.js site. Launched this new weekly banter format. Still experimenting with how often I actually want to publish, reckon weekly is about right but we'll see. Developer Tips and Tricks 💡 Quick git alias for better logs: git config --global alias.lg "log --graph --oneline --all --decorate" This creates a beautiful visual git history that's way more readable than the default log. Claude Desktop optimization tip: Keep conversations small and restart often. The message limit resets every 5 hours, but shorter conversations use fewer tokens per message. You can get 2-3x more usage by starting fresh chats instead of continuing long threads. (If you're weighing up Claude Code versus other terminal tools, I did a proper comparison of Claude Code vs Warp AI a while back.)

Skills are what MCP should have been 📝 Anthropic announced Agent Skills on October 16th, and I reckon this is one of those quiet releases that ends up mattering more than the flashy model drops. A skill is a markdown file with YAML frontmatter. That's it. No server process. No JSON-RPC. No WebSocket connections. No Docker containers. A markdown file. And the clever bit is how it loads. Level 1 is metadata. Name, description, trigger conditions. Costs you about 30 to 100 tokens and it's always in context. Level 2 is instructions. The actual "how to do the thing" content. Under 5,000 tokens. Only gets loaded when the model decides it's relevant to your task. Level 3 is resources. Referenced files, example code, whatever. Only pulled in when the instructions explicitly reference them. So you've got a system where 100 skills can sit in your context at a cost of maybe 3,000 to 10,000 tokens total. The metadata layer alone. The model reads the names and descriptions, figures out which ones matter, and loads only what it needs. Now compare that to MCP. Four or five MCP servers and you're looking at 40,000 to 60,000 tokens of JSON schemas. Loaded upfront. All of them. Whether you need them or not. Sitting in your context window like furniture in a flat you never use, taking up space and making the place harder to navigate. Most MCP servers were never about live data Here's the thing I keep coming back to. What were people actually using MCP for? Some of it was legitimate live data connections. Database queries. API calls. Fetching real-time information the model can't have in its training data. Fair enough. That's a genuine use case and skills can't replace it. But a huge chunk of the MCP ecosystem was procedural knowledge. How to deploy this thing. How to format commits. How to run the test suite. How to interact with Jira. Step-by-step instructions wrapped in a protocol layer and loaded as tool definitions. Tens of thousands of tokens to tell the model "when someone asks

AI Security Disasters This Week 🔥 Half a trillion in AI valuations. Eight thousand children's records nicked. Sudo is broken. Everything is on fire and we're shipping vibes. Right. Where to start with this week of AI security breaches and vibe coding gone wrong. A ransomware gang called Radiant (love the branding, lads) hacked a nursery chain called Kido and walked off with personal data on 8,000 children. Children. Not enterprise accounts. Not crypto wallets. Actual kids in actual nurseries. I don't usually get properly miffed about security news because frankly if you're still leaving RDP open to the internet you deserve what's coming. But targeting nurseries? That's a new kind of grim. Meanwhile: OpenAI hit a $500 billion valuation. Half. A. Trillion. We're living in a timeline where AI companies are worth more than most countries' GDP and a nursery chain can't keep toddler data safe. Cool. This is fine. The Hits Keep Coming 💀 It wasn't just the nursery hack. This week was a proper security shambles from top to bottom. Google Ads serving trojans. You search for something legitimate, click an ad at the top of Google, and congratulations, you've just installed malware. Google taking money to distribute malware is chef's kiss levels of ironic. The ad platform that prints money can't vet what it's printing. Fake invoices spreading RATs. Remote Access Trojans shipped via invoice PDFs. Because apparently we still haven't sorted out "don't open random attachments" after twenty-odd years of trying. The sudo exploit (CVE-2025-32463) got added to CISA's Known Exploited Vulnerabilities list. Actively exploited. In the wild. Right now. Sudo. The thing that literally gates root access on every Linux box you've ever touched. If that doesn't make you sweat a bit, you're not paying attention. Tile tracking devices flagged as a stalking risk. The thing you bought to find your keys can apparently be weaponised to find you . Reassuring. UK Co-Op attack costs hit $275 million. Drago

Your agents are a chaos machine 🎯 So HumanLayer dropped their Advanced Context Engineering piece last week, and buried in it is this absolute banger of a line: "Bad research -> bad plan -> bad code. A single wrong line in research cascades to widespread errors." That's Dex Horthy describing what happens when you chain AI agents together without checkpoints. And it's the exact same mechanics as a double pendulum. You know the double pendulum, yeah? Simple physics demo. One pendulum hanging from another. The top one swings predictably. The bottom one goes absolutely mental. Tiny changes in the initial swing of the top pendulum produce wildly different trajectories in the bottom one. Chaos theory in action. Looks like it's possessed. Multi-agent AI systems are double pendulums. Your research agent makes a small mistake. Misidentifies which module handles authentication. Gets one import path wrong. Reads an outdated API signature. Tiny error. Barely noticeable in the research output. Your planning agent reads that research and builds a plan around the wrong assumption. The plan isn't obviously wrong. It's coherent. It just starts from a slightly incorrect foundation. The deviation from reality is bigger now but still plausible-looking. Your implementation agent reads that plan and writes hundreds of lines of code. Code that's internally consistent but built on a foundation of sand. The cascade is complete. One wrong line in research became a hundred wrong lines in code. Why more agents makes this worse, not better Here's the bit that does my head in. The whole pitch of multi-agent systems is "more agents = better results." Specialise each agent. Divide the labour. Sounds reasonable. But every agent you add to the chain is another joint in the pendulum. Every handoff is another point where small errors amplify. A three-agent pipeline (research, plan, implement) has two handoff points. A five-agent pipeline has four. Each one is a potential chaos amplification. Sean Moran

The Headless Takeover 🖥️ IDEs had a good run. Then the terminals learned to think. Here's the thing nobody's saying out loud: terminal-based coding agents are eating headed apps for breakfast. And it's not even close. The Architecture Gap Every IDE-based agent - Cursor, Windsurf, whatever's launching next week - has the same fundamental constraint: IPC . Inter-process communication. The IDE runs here, the AI runs there, and they talk through some protocol layer. Extensions, language servers, message passing. It works, but it's a bottleneck by design. Terminal agents? Direct subprocess execution. No middleware. No protocol translation. You spawn a process, it runs, you get output. Done. 📚 Geek Corner IPC vs Subprocess : IDE extensions typically communicate via JSON-RPC, WebSockets, or custom protocols. Each message serialises, transmits, deserialises. Terminal agents skip all of that - they're just running shell commands as child processes with direct stdin/stdout pipes. The overhead difference is orders of magnitude. The Composability Factor Terminal tools are composable by default . cat file.ts | grep "TODO" | wc -l Thirty years of Unix philosophy baked into every interaction. Pipes. Redirects. Scripts. You can wrap anything - linters, formatters, compilers, test runners, deployment scripts - and the agent just treats them as tools. Try doing that in a GUI. You're clicking buttons. Waiting for panels to load. Fighting with extension APIs that change every release. Terminal agents don't care about your UI framework. They run commands. Commands compose. That's it. The Scaling Play This is where it gets spicy. How do you scale a GUI-based agent? You don't. One human, one screen, one IDE instance. Maybe you run a second window if you're feeling fancy. Terminal agents? Spawn ten of them. Spawn a hundred. Run them in CI. Run them on every PR. Run them overnight while you sleep. They're just processes - orchestrate them however you want. # This is trivial with terminal ag