Phil Haack

This is a really interesting article about writing agents with the Claude Agent SDK. It gets into design advice that you should consider when writing an agent with Claude. It chimes with what I’ve read about the development of Claude Code (write as little business logic as possible and concentrate on getting out of the way of the model). The general takeaway for me is from the three-block flow chart in the middle: Give the agent good tools/affordances in three categories: Gather Context, Take Action, Verify work. Do that at the right granularity, with good feedback, and then let the model do the driving. It’s deceptively simple, but it has a goldilocks quality to it. Trying to make a more complex flow chart with many more boxes and lines constrains the AI to just the things you could think of in advance and makes it overfit to what you know today. Trying to make it simpler by, for example, giving the agent a whole existing API as a single tool can overwhelm it with too much choice and then too much context in the responses. It’s definitely worth reading if you're interested in building or using agents, irrespective of AI vendor. https://lnkd.in/eKF2rXWb

7

I thought this was a good and very reasonable talk by Eleanor Millman on how to prioritize projects for a platform engineering team: https://lnkd.in/gaYtUHRH A few insights I took from it: - Unlike product features which can be more directly tied to revenue, platform engineering work is a couple steps removed. But that doesn't mean it's unimportant! Far from it, platform engineering projects can make everyone at the company more efficient, able to produce higher quality software, etc. - While "urgency" is always going to be a factor, you don't want to just be putting out fires, you want be able to prioritize work which is "high impact" ... even if that impact isn't felt immediately. - Good rule of thumb: prioritize "highest impact for lowest effort". - The talk has some ideas on what factors to choose for impact, and how to blend them. For instance "speed of development" is one factor, "cloud cost optimization" might be another. The weighting of different impact factors can change over time, depending on the needs of the business. I would say that a lot of companies don't have much methodology here but I can really see the value in codifying it. You can always change the methodology or the weighting if it's spitting out results that don't pass the smell test or you really feel it is leading the company astray. Clarity can give the org more freedom to put resources behind projects that would otherwise never be taken on. When things are unclear, prioritization still happens implicitly, but the decisions tend to be a lot more random and fear-based and the org is worse off as a result.

15

3 Comments

Agentic Coding Tools Are Forcing Better Documentation Anyone who’s joined an existing product knows the pattern. The "why" is often locked in tribal knowledge. Decisions, tradeoffs, and historical context are missing, outdated, or never written down. Documentation was created once, checked off, and forgotten. Agentic coding tools (Windsurf, Claude Code, etc.) make that impossible to ignore. These tools don’t just generate code. They reason across a codebase using context, constraints, and intent. That makes documentation a first-class input: → design intent → conventions and standards → explicit guardrails In large codebases, consistency won’t come only from reviews anymore. Documentation becomes part of how these tools behave. Bad docs don’t just slow teams down. They create risk — and agentic tools will amplify it. Well-maintained documentation lets both humans and agents move faster, with confidence. #AgenticAI #Documentation

20

I’ve had a project sitting in my guilt pile for years: nickberardi.com. I started that blog nearly 20 years ago, and for the last 12 years it was basically frozen in time. Like a lot of long-lived software, it didn’t fail loudly — it just slowly became harder to touch. Old stack, old assumptions, outdated deployment model, and growing friction every time I thought about modernizing it. For a long time, I treated it like a weekend project I’d eventually get to. I never did. Last week I decided to try a different approach. I gave my AI assistant (Lex) a lightweight goal to migrate it to GitHub Pages and expected to spend the next few hours cleaning up a partial result. Instead, in about 30 minutes, I had a working migration: content moved, static site generated, and deployment in place. Not perfect on the first pass, but absolutely good enough to get from “stuck for 12 years” to “live and improving.” That was the real lesson for me. The hard part wasn’t that I couldn’t do the migration. The hard part was the activation energy to start it. AI crushed that barrier. So when people ask how to get started with AI coding, my advice is simple: don’t start with a tutorial. Start with the one real project you’ve been avoiding. Use the $20 subscription you already have (ChatGPT, Gemini, or Claude), give it a concrete outcome, and iterate from a working draft instead of a blank page. That shift — from planning to momentum — is where the value shows up fast.

16

🔄 I think continuous learning is super important, so each week, I try to read/listen/watch broadly across engineering, AI, leadership, and strategy. A few highlights from this week’ 👇 Developer Productivity in 2025: More AI, but Mixed Results https://lnkd.in/grKgzpF7 AI tools are widespread, but productivity gains vary widely depending on how teams adopt and integrate them. Svelte 5 and the Future of Frameworks https://lnkd.in/gX63_dZb A conversation with Rich Harris on why simpler, more intentional frameworks may matter more than chasing complexity. How I Use LLMs as a Staff Engineer https://lnkd.in/gc935q2x A pragmatic take on using LLMs as a daily engineering aid—learning, exploring, and unblocking—rather than replacing core thinking. Start Finishing, Stop Starting: Why I Prefer Walk-the-Board Stand-Ups https://lnkd.in/gtX4_Pk4 Shifting stand-ups from status reporting to flow management to improve throughput and reduce WIP. Claude Code and What Comes Next https://lnkd.in/gS7ppMFP A look at autonomous coding agents and what they signal about the future of software development workflows. AWS in 2026: The Year of Proving They Still Know How to Operate https://lnkd.in/gjfPjGeR A critical view of how AWS must execute operationally as cloud, AI, and competition intensify. What Is the PESTEL Model for Business Analysis? https://lnkd.in/gGCAJ3FU A refresher on a strategic framework for understanding macro-level forces shaping business and technology decisions. From Chore to Habit https://lnkd.in/gKVYfrJJ How small, repeatable actions turn good intentions into sustainable habits. The Pulse #158: New Ways of Coding with AI Tools https://lnkd.in/gaUVcuiJ Emerging patterns in how engineers are actually coding day-to-day with AI assistants. How Engineering Leaders Can Better Leverage AI in 2026 https://lnkd.in/g3wSeKqV Practical guidance for leaders on adopting AI intentionally—across teams, tooling, and culture. When AI Writes Almost All Code, What Happens to Software Engineering? https://lnkd.in/gGdj7aM7 A thought experiment on how roles, skills, and value shift if code generation becomes nearly free. Building Internal Agents https://lnkd.in/gD6usBif A practical series on designing and deploying internal AI agents to automate real work inside organizations.

34

5 Comments

While everyone was talking about Opus 4.6, for me the true killer feature of the recent Claude Code updates is the agent teams. It's been something i've been trying to achieve with customization for a while. Custom agents, orchestration scripts, specific CLAUDE.md instructions to coordinate work... with some degree of success. But what Anthropic shipped natively is a WHOLE different level. What makes this stand out is the inter-agent communication. We're not talking about simple fan-out/fan-in where you spawn workers and collect results. These agents talk to each other. Peer-to-peer messaging, dependency-aware task graphs that auto-unblock, agents that self-claim work from a shared task list. The lead can even enter Delegate Mode where it does ZERO implementation, only coordination. The image below is from one of my setups. A team manager orchestrating a librarian agent, a PhD lead, and 5 research sub-tasks with blocking dependencies. The librarian unblocks the research tasks, the PhD lead aggregates everything. All coordinated autonomously. And with this a whole new world of orchestration just unveiled itself. Distributing work across agents is the "easy" part. You break down tasks, assign owners, define dependencies. The HARD part, and what MOST stands out now, is aggregation. How do you take the output of 5 parallel agents, each with their own context window, and synthesize it into something coherent? That's the new skill. Anthropic themselves used 16 parallel agents to build a 100,000 line Rust C compiler that compiles the Linux 6.9 kernel. No human actively coding. ~$20,000 in API costs over ~2,000 sessions. We went from pair-programming with AI to managing AI engineering teams. The skills that transfer are the ones from engineering management: task decomposition, context management, knowing when to intervene vs let the team self-organize. This is a new paradigm, and i think it opens up several possibilities we haven't fully explored yet. ref.: https://lnkd.in/dVCe344z

68

12 Comments

Don't believe the BS that you can use Claude Code for free. Ollama recently made their API compatible with Claude Code. Many creators quickly jumped on the opportunity to farm engagement with the hook: "You can now use Claude Code for free!" My thought? Claude Code without Opus 4.5 is not Claude Code. Period. But this is exciting news. Not because I can use Claude Code for free, but because I see an opportunity to optimize costs by delegating easier tasks to local LLMs. The key question is: what tasks can local LLMs handle? I tested out 7 local LLMs. In this post, I will explain the BS and share my 1st experiment. -- Why the BS? Claude Code has been praised as one of the best AI tools by its users, not only for coding but for many other tasks. But the price feels steep to many. The $20/month plan is not enough for any serious work. You need to at least subscribe to Max 5x ($100/month). Many heavy users, including me, subscribe to Max 20x ($200/month). It’s a steal. But still, many were eager to try it but aren't ready to pay. Ollama's recent announcement means you can buy a Mac, a Strix Halo, or a GPU and use Claude Code for "free" with local LLMs. It’s appealing, as it is a one-time investment, and you can use the machine for other purposes. Creators are leveraging this opportunity to farm engagement. But the reality? Claude Code without Opus 4.5 is not the same Claude Code we praised. Local LLMs are far less intelligent. -- But for those who understand the difference, we see an opportunity to optimize costs by delegating some easier tasks to local LLMs. I'm interested in finding out what tasks local LLMs can handle. This is my typical flow when using Claude Code. This is for coding, but I have similar flows for marketing and content creation. 1. Research and planning 2. Create PRD and implementation plan 3. Break plan into bite-sized tasks 4. Implement + review with reflection pattern 5. Final review with agents 6. Final review and QA by me Based on my quick tests, we can forget about asking local LLMs to do research and planning. All of them failed at a simple instruction: "Visit https://learnparrot.ai/ and tell me about the website." So, I think the most viable use cases would only be (4) — implementation + review loops. While it looks like a very narrow use case, it is where we burn a lot of tokens. So I think it is worth a try. The main selection criteria for this will be instruction-following capability. One very common task is to refer to code samples or templates to code a new feature or page. This is a good test of instruction-following. So, I crafted my first test: - Used Opus to create HTML that I can screenshot as a LinkedIn carousel to display info for each model. - Turned one of the pages into a template and deleted the rest. - Asked each LLM to refer to the template to code its own page, given its specs. Swipe the carousel to see the results. Who would you hire? #LocalLLM #ClaudeCode #VibeCoding

20

10 Comments

I've been doing some gardening in the #Knative project recently, and I've been reminded of a couple patterns which really make contribution easier / harder: * DOCUMENT your toolchain! Minder has a somewhat-short list of external utilities, and then a `make bootstrap` that will do a `cd tools; go generate`, which kicks off a bunch of go tooling install onto your workstation. It's not really hermetic, but it gives something for both new developers and CI to hang their hat off. We then check in the generated code and check that the code generation is up-to-date on PR submit, so sometimes you need to re-run `make bootstrap` when something like sqlc changes. * Don't let your environment rot! With all the package management ecosystems out there, it seems like software updates are always falling behind. Set up something like dependabot for _every_ ecosystem you're using, and don't let things rot for too long. (Sorry, my side projects... I see you over there! I'm going to get better!) * Build warnings are a huge hassle for folks who are new. "Oh yeah, it always does that" is great when you have someone sitting next to you who can tell you whether or not it's serious, but the rest of the time, you're either chasing ghosts, or missing important feedback. * All the above stuff is NOT a "good first issue" to fix. Knowing what "good" looks like, and the acceptable quality bar for the project is your culture, and it's up to maintainers to keep that stuff... maintained. (Yes, it's fun to write new features or take that bad old code out behind the shed... but asking someone new to set the tone for your project is avoiding your responsibility as a maintainer.) With the above rant over -- many of the folks maintaining these open source projects are doing it out of love! Share thanks with them if you're benefiting from all the ugly grunt work they're doing on your behalf! If you don't know what thanks looks like -- ask! Maybe it's a GitHub Sponsorship, maybe it's writing something positive, maybe it's answering a question on Stack Overflow, or closing some old issues...

18

2 Comments

I love Rails. I've built my wealth on it. That's exactly why I think we need to have an honest conversation about its biggest blind spot. Eileen M. U. gave a brilliant talk at Rails World last year: "The Myth of the Modular Monolith." After 6 years of modularizing Shopify's monolith, she concluded: "You can't solve human and cultural problems by changing your architecture." She's right kinda of about the culture part. But stopped one step short. Rails doesn't just allow tight coupling. It incentivizes it. ActiveRecord makes every model globally accessible from anywhere. Any controller, any model, any job can reach into any table through any association chain. There's no boundary enforcement. No import restriction. No compilation step that says "this module shouldn't know about that one." When your framework makes coupling the path of least resistance, blaming developers for coupled code is like blaming water for flowing downhill. Shopify tried to fix this with Packwerk. It just give you a map not a real solution. Rails Engines? Been there, done that. They are miniature apps that provide functionality to their host applications. They don't enforce real isolation and they weren't designed for progressive extraction. But this isn't a Rails problem. It's a missing tool problem. Look at what Nx did for the Node/TypeScript ecosystem: → Module boundaries enforced at the import level, not via YAML to-do lists → Dependency graph visualization built in → Affected-only CI: only test what actually changed → Clear public API per module, everything else is private by default → A real path from monorepo module to extracted service Nx didn't replace Node. It gave Node developers the guardrails to build modular systems naturally. The right thing became the easy thing. By default. Rails deserves the same. Imagine a Rails-native tool that: • Enforces module boundaries through autoload paths, not opt-in linting • Gives each module a public API (explicit exports) while keeping internals private • Generates a live dependency graph from actual code usage, not manual YAML declarations • Runs affected-only CI based on that graph Not a replacement for Rails. A companion that makes Rails' conventions work at scale. Eileen is right: culture matters. Education matters. Leadership incentives matter. But culture alone didn't give us CI/CD. Tools did. Culture alone didn't give us code formatting standards. Linters did. Culture alone won't give us modular Rails applications. Rails gave us developer happiness for building products. Now we need the same philosophy applied to building organizations of code. The myth isn't the modular monolith. The myth is that we have the right tools for one. Who's building this? 🎥 Eileen Uchitelle — "The Myth of the Modular Monolith" (Rails World 2024) https://lnkd.in/dabvzHQm

13

What I'm Reading This Week 📚 🤖 Vibe Code Reality Check Steve Krouse's piece argues that "vibe coding" where you "forget that the code even exists" creates legacy code nobody understands. Programming is fundamentally theory building, not just producing lines of code. This resonates - I recently spent hours trying to fix a frontend bug with Claude Code and Gemini CLI stuck in a dead loop of guesses. Two minutes of human inspection found the inefficient hook render. We still very much need the human (expert) in the loop. https://lnkd.in/g_Dt-_kz 📐 Mathematics as Code Dan Abramov's exploration of Lean shows how mathematicians can treat mathematics as code - breaking it into structures, theorems, and proofs that are statically checked and composable. His playful example of "haunted math" where 2=3 demonstrates how axioms shape mathematical reality. Always fascinating to see bleeding-edge programming language theory, especially when it bridges math and code in such elegant ways. https://lnkd.in/gebHeMSU 💻 Local LLMs Innovation Simon Willison highlights how his 2.5-year-old laptop can now write Space Invaders using GLM-4.5 Air and MLX. Open source models are rapidly pushing the frontier of what's possible on a chip. The future where we get GPT-4 level intelligence running on phones feels closer than ever and a powerful enabler for humanity. 🚀 JavaScript's Wild Decade Jamie Birch's comprehensive dive through JavaScript runtimes reveals a staggering ecosystem - from Node.js to Cloudflare Workers to React Native's Hermes. I remember when Apple had a strict no-JS-runtime policy for the App Store. We've come so far that every platform now has multiple JS engines optimized for specific use cases. The proliferation shows JavaScript's incredible adaptability across contexts. https://lnkd.in/g843sYBk 📊 Amazon's Dev Experience ROI Amazon's "Cost to Serve Software" framework quantified a 15.9% reduction in delivery costs through developer experience improvements. The key insight: giving developers back time and reducing toilesome work. For a company with 1,000 developers, a 15% improvement translates to $20M in cost avoidance. Good concrete ROI numbers on investing in developer productivity. https://lnkd.in/ghv5CTfa Which trend do you think will have the biggest impact on software development: local AI democratizing access, the continued JavaScript runtime explosion, or finally having concrete metrics for developer experience ROI? #AI #JavaScript #DeveloperExperience #Programming #LocalLLMs #VibeCoding #SoftwareDevelopment

9

2 Comments

"Now that code is free..." Any assertion that follows this is predicated on a falsehood. Plausible-looking code might now be cheap. But *working*, reliable code that can be changed at low cost without breaking it? For most teams, that's even more expensive now.

41

11 Comments

SDK documentation is not supplementary material... it is a vital component of the SDK itself. It lets developers harness the SDK's potential by serving as a highly sophisticated technical bridge. However, the tone must be instructional, and the approach must be simple. Here is a quick explainer video on the need for SDK documentation and its essential components.

19

Developers weren’t just builders. They were gatekeepers. If you couldn’t code, you didn’t create. You waited. On engineering bandwidth. On roadmaps. On someone else’s priorities. Syntax was the wall. Know where the semicolon went? You shipped. Didn’t? You stood outside. That divide shaped more than workflows. It shaped status. Developers got the leverage. The scarcity gave them the power to decide what shipped and when. Everyone else adapted around them. It wasn’t about being smarter. It was about access — and access wasn’t evenly distributed. Some people were in the right rooms early, tripped into syntax, and built from there. Others never got the chance. That was the difference. But syntax was only the first kind of alpha. The second was quieter. Harder to see. More enduring. System knowledge. Knowing which database could survive Black Friday traffic. When to debounce vs. throttle. How to shard writes across regions. Not just writing code — architecting it. That’s the tacit layer. Built from war stories. Outages. Scaling pain. Years in the trenches. It’s still here. And it still matters. For now. I remember the first time I tried to shortcut it. I’d tell Claude what I wanted. It would spit out code. I’d paste it. It would break. I’d send back the error. It would try again. Loop by loop, something shifted. Reddit called it “copy-paste monkey.” They saw a hack. I saw a door opening. People who’d been locked out started building demos. Then products. Then real companies. The wall between “technical” and “non-technical” was never about intelligence. It was about translation. And now, translation is free. What matters now isn’t syntax. It’s clarity. How well you can think. Break things down. Iterate. That’s what the agent understands. And that’s what it rewards. The syntax advantage is gone. Developer privilege is flattening. System knowledge is next. Today, the agent can’t always choose the perfect database. But if you tell it the trade-offs, it will. If you give it context, it will architect with precision. That tacit edge still holds. But only for now. Soon, even that will be embedded. And leverage will shift again — to anyone who can think clearly enough to guide the machine. That shift isn’t coming. It’s here. And it’s not going away.

18

2 Comments