Chris Douillard

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

Adding Document Understanding to Claude Code 📑🤖 Coding agents are awesome but they don’t natively understand docs (they kind of do, but it sucks). This limits their ability to build business applications - think about anything from a financial copilot to contract reviewer to rfp synthesizer to synthesizing PRDs. I wrote a blog to capture core patterns for adding document understanding to Claude Code - applicable to coding agents in general. This both helps Claude Code 1) get enterprise context when building apps, and 2) allows it to build more agentic, robust apps in general. 1️⃣ Add an MCP server that preindexes your file knowledge base 2️⃣ Let Claude Code loose on your filesystem with the right CLI tools for understanding files. 3️⃣ Give Claude Code context on core modules for document understanding and agentic workflows - this last step is important if you want to build “better apps in general” and not just “rule-based apps”. Blog: https://lnkd.in/g4EEFftk The blog offers general principles regardless of whether you’re using our stuff, because we fundamentally think that coding agents + docs leads to a ton of useful applications. Of course we are deeply investing in tooling in this space too (some referenced in the blog), a lot of it dependent on LlamaCloud. Check it out: https://lnkd.in/g9Wpqn7w

213

2 Comments

Six things. None of them are AI. I've spent 30 years building technology for MGAs. This is what they actually need from their tech teams. 1. Systems that share data without a human in the middle. Most MGA platforms were built in silos. The policy system doesn't talk to the claims system. The claims system doesn't talk to the bordereaux. Someone manually bridges the gap every single day. That's a technology failure, not a people problem. 2. Processes mapped before they're automated. Half the automation projects I've seen failed because they automated a broken process. Automating chaos gives you faster chaos. Map first. Automate second. 3. Reporting that runs itself. MGAs spend hours building claims bordereaux, premium bordereaux, and carrier packs every month. That's not underwriting. That's data assembly. It should be a button press, not an afternoon. 4. A single version of the truth. Ask five people at an MGA what the current GWP is and you'll get five answers. That's not a data problem. It's an architecture problem. 5. Technology built for MGAs, not adapted from carriers. Most insurance software was designed for carriers and sold down to MGAs. The workflows don't fit. MGAs end up bending their operations to fit the software instead of the other way round. 6. A tech team that understands the business. The best technology change I've seen in insurance came from developers who sat with underwriters. Watched how they worked. Asked questions. The worst came from developers who built to spec without asking why. So before the next AI conversation: which of these six is still missing? #InsuranceTechnology #MGA #Operations #InsurTech #InsuranceInnovation

20

14 Comments

If you're looking for a new docs framework for your dev tool, I can't recommend Docusaurus enough. 1. You can change the appearance of any component—no matter how big or small—by ejecting its raw React code into your source tree. I've ejected almost all of its major components and restyled them with Tailwind. 2. It supports content written with MDX, which is like Markdown but better. MDX lets you write JSX tags so you can render React components (like badges and banners) directly inline your content. No more messy templating. 3. It bundles Prism for code snippet highlighting. So you if you want to change how each and every token of your language gets styled—which I do—you can override it with a simple centralized map—which I have. 4. You can swap out its on-site search engine with Algolia, now widely considered the best option for developer sites. It is, in other words, the perfect tool for people like me who are obsessed with every pixel.

118

16 Comments

If buying insurance were like ordering on Instacart, 41% of the carts would be missing a checkout button. When I was at Instacart, we obsessed over this flow. If users added items to their cart but didn't buy, we investigated why. A missing checkout button would be a catastrophe. But nearly 2/3 of home and auto insurance policies are still purchased through a human. For these agents, the "checkout" isn't a button, it's a verbal question. And it turns out, it’s often missing. We recently analyzed thousands of agent interactions via Genfin, specifically looking for calls where the customer was qualified and ready. The data was eye-opening: 41% of agents never invited the customer to move forward. They did the hard work. They built rapport, explained the carriers, detailed the coverage, and answered questions. But when it came time to bind? Silence. They never asked "Do you want to proceed?" or "How would you like to pay?" They essentially walked the customer to the register and then walked away. With Genfin, the agent <> customer interaction isn’t a black box. It’s a measurable funnel that links the free-form communication, the screen activity, and the final sold policy. The root cause to a broken funnel isn't always complicated. Sometimes, it's simply ensuring the customer has a clear path to purchase.

17

As Fred Brooks wrote decades ago: “Adding manpower to a late software project makes it later.” Coordination isn’t free. New devs mean onboarding, syncing, and re-aligning. The fastest teams aren’t the biggest, they’re the ones that communicate best.

668

30 Comments

How can you make sure orchestrating agents across many frameworks doesn't cost you a fortune? Today, Caelum Forder and I look into agent sessions from Coral Protocol.

16

We can’t make good software in a vacuum. When we started Ressio, I didn’t just talk to builders…I asked them to help shape the product. One builder told me, “I started with Excel. If your estimating tool doesn’t feel like that, I’m not going to use it.” So we built it that way. It’s not just about features. It’s about feel and how quickly a builder can sit down, punch in numbers, and move on. That’s what being builder-first really means. Listen first. Build what they ask for. And don’t make them change how they work just to use your tool.

19

3 Comments

3 reasons why we build software and service as one team: We don’t build tech *for* operations at Tandem. We build tech *with* operations. Here’s why that matters; 1) Fix friction at the root. If a vet has to click 5 times to do something that should take one, we fix it. Not just because it’s “inefficient”. But because it creates cognitive load, slows care delivery, and compounds under pressure. Less friction = faster throughput, fewer errors, and lower burnout. 2) Close the loop between builders and users. The person who writes the feature talks directly to the person who uses it. That means issues surface faster, fixes are more accurate, and nobody ships something that “technically works” but operationally fails. It’s not just “faster iteration” - it’s tighter alignment with reality. 3) Scale the system, not the sprawl. New clinics, new roles, new workflows. We don’t layer on SaaS duct tape. We evolve a system designed to flex with operational growth. That means fewer integration points, tighter control, and a consistent experience from core to edge. We don’t treat tech like a layer. We treat it like a nervous system. Because when you’re delivering care in the real world, you can’t afford delay, dissonance, or dropped signals. That’s why we built Tandem the way we did: One system. One team. Zero silos. Because when service and software evolve together, the whole organism gets smarter, faster, and stronger over time. ------------- Hi, I’m Doug. I’m the Chief Technology Officer at Tandem. We’re engineering the backbone for modern pet care. Follow me for posts on: * How we build tech with ops, not for them * How we build tech tools that scale cleanly * Scaling hybrid companies without SaaS bloat

27

2 Comments

Most contractors we work with have been burned by bad software. We’ve all heard the same horror stories: Sales rep overpromises, onboarding under-delivers, customers end up with a tool that's nothing like what they thought they were getting. At OneCrew, we're doing things differently. We designed our entire sales process to rebuild trust with contractors in 3 core ways. First, we ask what went wrong last time and listen. Understanding > selling. Second, our sales process is honest. It's just as important to tell customers what we don't do as it is to highlight our capabilities. Third, we're clear on what onboarding looks like and the effort required upfront. Our goal: by the end of the sales process, you know exactly what you're buying. You're confident it's the right decision for you and your business. And when you start onboarding, there are no surprises - it's exactly what you expected.

23

The Batch Size Trap When systems slow down, people start bundling changes into bigger releases. This seems rational. If each release costs you coordination overhead, why not make it count? Ship more at once. But here's what actually happens: you've made everything worse. Large batches are a trap. When something breaks, you have no idea which change broke it. The debugging surface explodes. And because the batch was large, the breakage affects more users, more systems, more everything. The blast radius scales with batch size. There's a deeper problem though. Large batches hide information from you. When coordination costs rise and cognitive load increases, the system is failing. But leadership doesn't see it. Releases are still happening. Goals are still being met, more or less. Sure, things feel harder, but give it six months. Six months later, everything collapses. Velocity craters. Incidents spike. People quit. Nothing changed. The system was failing from the start. Large batches just delayed the signal. Small batches do the opposite. They're a continuous health monitor. When something breaks, you know exactly what broke it. When coordination costs rise, you see it immediately in longer cycle times. You can't hide dysfunction behind quarterly releases. Think of it like an iceberg. Above the waterline you see events - releases, incidents, metrics. Below it, invisible, are the structures that cause them: technical debt, coordination overhead, social friction. Large batches keep the waterline high. You only see catastrophic events. Small batches lower it. Now you see the little delays, the minor bugs, the subtle failures. These feel annoying, but they're gifts. They're telling you where the icebergs are before you hit them. Here's another way to see it. Imagine your workflow is plumbing. Large batches force huge volume through at once. If there's a blockage - high cognitive load, unclear ownership -pressure builds until something bursts. Small batches are a steady trickle. You see exactly where the leaks are. You find blockages before they become explosions. Small batches won't fix a broken system. But they'll tell you it's broken while you can still do something about it. #SystemsThinking #DDD #WardleyMapping #EventModeling #TeamTopologies

24

3 Comments

Vibe: A Framework for Agentic Software Delivery I wrote up how Vibe approaches agentic delivery with a plan-first loop, tiered workflows (/vibe, /lite, /full), and “guards” as safety contracts that every build must pass before it can close. If you’re experimenting with agentic delivery and want something more structured than ad hoc prompting, this might be useful. Read the essay: https://lnkd.in/gA8in4SN

40

1 Comment

A typical example of today’s shallow GenAI integrations, more marketing than meaningful help. The same goes for the “agent” buzzword we are overusing. If GenAI or an agent truly improves the experience, it should be obvious from the interaction. The best tech works quietly in the background, solving real problems without needing a label.

16

3 Comments