Unfiltered Musings & Signals
Short-form epiphanies, building in public updates, local LLM quantization breakthroughs, and architectural reflections.
The Sonos app launch disaster, which involved a buggy and incomplete new app released in May 2024, had a significant and far-reaching impact on the company. The launch caused significant financial losses for the company, including a stock price decline of approximately 13%. Their CEO, Patrick Spence, stepped down and the company also experienced employee morale issues and implemented layoffs as a result of the app disaster. Their interim CEO highlighted two deliberate mistakes that underpinned the debacle 1. It knew the new launch version of the app was missing functionality which wasn’t used by many, but was very important to those who did use it 2. It radically changed the UI, without fully appreciating how unpopular this would prove. These real-world examples, carry invaluable lessons for all. Change management cannot be an afterthought when launching transformational products. Always pressure test your product with the change of pace of human (consumer) behavior. Don't conflate lab (ideal) situations for real world.
In the aim to be as polished and perfect as possible, every LinkedIn post has a level of sameness that is hard to miss. We all want to put out the perfect polished posts in the shortest period of time. We sharpen our prompts more than our writing and thought. As AI slop becomes pervasive, creativity, original human thought and trust will become increasingly important and valued.
Over the past few months, I’ve been deep in the trenches using tools like Antigravity and OpenCode. Here are 10 core insights on system architecture, model quirks, and token economics: 🛠 Architecture & Workflow 1. Models are poor architects: You can't rely on them for end-to-end design. They always take the shortest path to complete a prompt, often violating application intent. 2. The 80/20 process inversion: AI-powered engineering flips development. ~20% of the time is now spent building; ~80% goes into testing and validation. 3. RAG + Guardrails isn't enough: Production-grade accuracy requires a multi-agent Proposer–Evaluator–Judge construct rather than simple tool calls. 4. Leaner harnesses win: Frontier models perform better with minimal constraints. Save heavy, instruction-dense harnesses for mid-tier models. ⚡ Model Behavior & Realities 5. Model psychosis is real: LLMs routinely get trapped in loops, repeating the exact same past mistakes over and over. 6. Performance degradation is guaranteed: Newly released frontier models peak on Day 1 and suffer silent degradation/psychosis over time. Local open-source models avoid this moving-target issue. 7. All models lie: Hallucinations are inherent. Smaller local models are more susceptible, but top-tier LLMs are far from immune. 8. The Context-Confidence Flywheel: Larger context windows directly elevate output quality, driving higher confidence in results. 💰 Economics & Strategy 9. Not every token needs to fly first class: Build and iterate with frontier models, but route production inferencing to local models for viable unit economics. 10. Prompting for path vs. task: Without explicit constraints, models will sacrifice proper multi-stage logic just to check off task completion. If you’re building in this space, what’s your biggest operational bottleneck right now? Have you observed some of the same quirks?
The future of UI isn’t human-first. It’s agent-first. We’re shifting from applications designed to be operated by humans to applications designed to be operated by AI agents—and simply guided by humans. So, how do you design for the agentic era? The blueprint has actually been hiding in plain sight over the last 6 months inside agentic IDEs like Claude Code and Antigravity. Looking at these patterns, the architecture of future agentic applications breaks down into 5 core components: 1. Work Organization Pane: Folders, projects, and contextual history to ground the task. 2. Dynamic Canvas: The primary workspace that renders live outputs and artifacts. 3. Agent Explainability Pane: The "under-the-hood" view showing which agents are working, their reasoning, and execution steps. 4. Intent Pane: The conversational interface where human intent transforms into action. 5. Cost of Work: Real-time visibility into token usage, compute, and execution cost. We are transitioning from UI operators to system directors. What patterns are you seeing emerge in agentic UX? What’s missing from this stack?