John Steele

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

99% success rate on a site we’d never seen before. Not bad for launch 🚀 Developers build on Deck to interact with websites that have no APIs, reading or writing data wherever users need it. What’s remarkable is the quality and consistency, even across new, unseen systems. Auth Agents are redefining what “integration” means. Check our guides if you're ready to start building: https://lnkd.in/eG4h6aMS

84

Integrations shouldn’t be features locked in someone else’s platform. They should be code, living, versioned, and owned by you. That’s what Membrane Packages make possible. Most integration platforms give you configuration UIs and prebuilt connectors. When APIs change or vendors sunset, your integrations break, and there’s nothing you can do. You don’t own the code. You don’t control the logic. You’re renting connectivity. With Membrane, integrations become part of your product’s DNA. - The Membrane Agent reads API docs, understands your use case, and builds integration logic automatically. - The Membrane Engine runs that logic reliably, managing authentication, flows, retries, and observability. And what you deploy isn’t a config, it’s a Package. Each Package bundles YAML + JS code that connects your product with external apps, combining Engine elements like: Actions, Flows, Data Collections, and Events. You can build Packages for any use case: - Single-app Package - one connector (e.g. get Slack messages into your product) - Multi-app Package - unified logic across multiple apps (e.g. sync messages from all comms tools) - Custom Package - build for any new app with an API (e.g. import contacts from a new CRM) These are real, portable integration blocks, versioned, inspectable, and fully owned by you. Run them anywhere: your repo, your cloud, or on-prem. Find out more about Membrane’s Packages here: https://lnkd.in/ep4xA8ay

297

4 Comments

Your software deal might be worthless without a source code escrow clause. Most SaaS or licensing agreements never ask: What happens if the vendor disappears? I’ve seen companies pay millions for mission-critical software, only to: Lose access when the vendor goes bankrupt. Be stuck with compiled code, unable to fix bugs or integrate. Face months of downtime because there’s no legal right to the source code. The fix: Add a source code escrow clause with a neutral escrow agent. Define release triggers (bankruptcy, failure to support, breach). Ensure the escrow includes documentation, builds, and dependencies. Without this, your software license is just a promise with no backup plan. _ Hello, I’m Gvantsa, a Partner at GBPLO. I specialize in providing thorough legal support to entrepreneurs facing diverse business challenges and building efficiency in legal ops.

31

18 Comments

Custom software feels smart. Until it doesn’t. Early on, the calls are quick. Move fast. Keep it lean. Ship what users want. But at $10M ARR, those early choices start to show cracks. Here’s what breaks: 1️⃣ It wasn’t built to grow ↳ The tools don’t scale ↳ Updates feel risky 2️⃣ Too much lives in people’s heads ↳ Only a few know how it works ↳ If they leave, you’re stuck 3️⃣ The fast way becomes the hard way ↳ Quick fixes pile up ↳ And small issues turn into big ones 4️⃣ What works now? ↳ Tools you can reuse ↳ Clear notes anyone can follow ↳ Tech that’s solid, not shiny 5️⃣ Most problems aren’t bugs ↳ They’re things no one saw coming ↳ You don’t need more engineers ↳ You need fewer unknowns Getting to $1M is about speed. Getting to $50M is about structure. If your team is feeling the strain, you’re not alone. ♻️ Repost if you’ve watched fast code slow down a good team 👉 Follow me for more real stories on what actually scales

57

32 Comments

What should Non-Technical Founders know about building Custom Software? We walk clients through this process regularly and put together some tips that could be helpful even before you START talking to Development Partners. https://lnkd.in/eRGsgwq3

12

1 Comment

Zero code administration of the Redwood Quoting interface is now available. This includes a one-click migration from the JET UI to Redwood.

126

7 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

Attending RailsConf and talking to folks, my biggest realization is just how expansive Ruby on Rails’ usage is, just that it doesn’t get spoken about publicly as often as other frameworks / technologies. Rails just seems to be silently chugging along in many companies’ tech stacks for more than a decade while happily helping the company scale. If there was one piece of tech I wish was actually hyped up way more than it is, it would be Rails, for how much productivity gains it brings to the table.

43

Entitlement systems weren’t built for agents. They were built for humans. Humans who click, who understand context, who have login sessions and MFA. Not autonomous processes making thousands of API calls a minute. At Identiverse, Tom Peri nailed this distinction. He broke down why traditional IAM patterns - roles, scopes, coarse-grained auth - completely fall apart when you introduce AI agents. We’re not just dealing with “who has access.” We’re dealing with how much, when, why, and on whose behalf, all in real-time. ▪️ Dynamic quota allocation ▪️ Session-scoped usage limits ▪️ Agent-aware observability We need entitlement systems that behave like programmable APIs, not static config files. If you're building anything involving agents, usage metering, or delegated access - you should read Tom’s write-up. Hats off, Tom 👏 This is where access control needs to go. Link’s in the comments.

23

2 Comments

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