Every team has work it repeats the same way every time. The multi-step process that lives in one person's head and gets done a little differently depending on who runs it. We built Pipelines for that. Pipelines are repeatable, multi-step workflows in Unstoppable Code. Encode a process once, then run it the same way every time, with AI agents doing the real work, not just build scripts. → Bundled presets out of the box, or build your own → Create one in plain language with the Pipeline Assistant. Describe what you want, it writes the pipeline → Schedule pipelines to run automatically. Set up a Triggered Activity, and generate the schedule in plain language too → Sensitive values stay in environment variables → Runs are durable and resumable. They survive a restart and pick up where they left off → Pipelines hook into tools you've already configured, like Linear for logging tickets One of the most useful ships with the product: a multi-agent code review that reviews the code in a worktree across multiple providers, hands back a report, and can suggest the next actions to take. Supervised process, not fire-and-forget. You stay in control at every step. Try it today: https://lnkd.in/eKvKiFzt

Every team has work it repeats the same way every time. The multi-step process that lives in one person's head and gets done a little differently depending on who runs it. We built Pipelines for that. Pipelines are repeatable, multi-step workflows in Unstoppable Code. Encode a process once, then run it the same way every time, with AI agents doing the real work, not just build scripts. → Bundled presets out of the box, or build your own → Create one in plain language with the Pipeline Assistant. Describe what you want, it writes the pipeline → Schedule pipelines to run automatically. Set up a Triggered Activity, and generate the schedule in plain language too → Sensitive values stay in environment variables → Runs are durable and resumable. They survive a restart and pick up where they left off → Pipelines hook into tools you've already configured, like Linear for logging tickets One of the most useful ships with the product: a multi-agent code review that reviews the code in a worktree across multiple providers, hands back a report, and can suggest the next actions to take. Supervised process, not fire-and-forget. You stay in control at every step. Try it today: https://lnkd.in/eeceTCwn

There’s a vanity metric spreading through the industry right now: how much code you can generate in how little time. 60,000 lines in a weekend. A full application scaffold in an afternoon. Entire features shipped from a single prompt session. It’s impressive. It’s also not the part that matters. Because generating code was never the hard part of software delivery. The hard parts are: - Does it integrate with your existing systems? - Can it be tested, deployed, and rolled back safely? - Is the data handling secure and compliant? - Can someone other than the person who prompted it actually maintain it? - Does your infrastructure support running it in production? Code generation is step one of a process that has fifteen more steps, and that’s where things get stuck. If anything, those other steps have gotten harder. Because now you’re reviewing and owning code that no human fully wrote, debugging logic that emerged from prompts rather than design decisions, and trying to fit AI-generated output into pipelines and environments that weren’t built for this velocity.  And the question also comes up:  Can you effectively review, in a timely and effecient manner, to complement the productivity gains from AI-assisted or developed software? The organizations that figure this out won’t be the fastest at generating code. They’ll be the fastest at getting AI-generated code safely into production and keeping it there. That’s AI rescue. And it's a very different skill set from the one that generated the code in the first place.

When you pair Claude Code with n8n's MCP and you can build almost any workflow you can think of. First, what's an MCP? Short for Model Context Protocol. It's a standard way to plug an AI straight into your real tools and data, so it can read from them and take actions inside them, live. So instead of guessing how n8n works, Claude Code reads the real node library and builds against it. Less guessing, fewer broken builds. n8n's own assistant is genuinely good. Give it a task and it maps a workflow on the canvas. But it stops at the canvas. Pulling credentials together, connecting the other tools a build actually needs, that's still on you, manually. Claude Code with the MCP isn't boxed into one canvas. It can reach into your other tools, pull a sheet, create one, gather what the build needs. Add Whispr Flow on top and it's even faster, talk the idea out loud, let it type, and it builds while you're still thinking. Here's the part I won't oversell: Claude Code can help architect the build, but it doesn't always catch the failsafes and edge cases your business actually needs. That's still a human job. You need to know the problem you're solving, and think through what happens when it breaks. If you want speed from idea to automation, this is the fastest way I've found. Have a look for yourself.

Working with Claude Code recently, I noticed a recurring bottleneck: the CLI is only as good as the context you give it. But repeatedly re-feeding it documentation and guidance for subtasks felt repetitive and inefficient. So I built a custom Agent Skill to automate the whole process. How it works: Instead of dumping massive documentation sets upfront, the custom skill handles progressive context loading. When Claude needs reference material for a specific task, the skill automatically fetches and injects the precise docs needed—on demand. The results: ⚡ Smarter token usage: Avoids polluting the context window upfront, which keeps token overhead low and response times fast. ⚡ Higher accuracy: Keeps the model focused on the immediate task without "instruction dilution" from irrelevant docs. ⚡ Zero wasted effort: No time spent copy-pasting reference docs or managing repetitive prompts manually. The best part of modern AI dev tools is that they aren't static—we can build workflows around them to fit our exact dev loop. #SoftwareEngineering #ClaudeCode #DeveloperExperience #AITools #DevProductivity

People spend less time inside platforms and more time in #Claude, and giving those agents access to your production data is where the leverage is. It lets them reason about your actual business. The problem is that production data is shared truth. One bad write corrupts it for everyone downstream, and one vague request will quietly produce ten different tables. Enabling the AI and protecting the data can feel like opposing instincts. Software solved this fifteen years ago with git and CI/CD: branch, write, validate, merge. Our new post shows how git-for-data brings that same model to data, so any person can manage data like code. On July 14, Bauplan is hosting a webinar going deeper on how agents write to production without breaking it, but as a trailer, you can read the blog here: https://lnkd.in/eZ3sUUAB

Today I saw something that made the idea of “debugging a CI failure” feel very different. Our CI pipeline started failing on Postgres-related tests. Nothing obvious had changed on our side, so I started investigating using Claude. Very quickly, it identified the root cause: a new release of pgvector that landed ~10 hours earlier had introduced a subtle behavioral change in how small tables are handled. That change was enough to break our test assumptions. From there, something interesting happened — the entire debugging + fixing loop became almost fully automated: - The regression was identified and explained (including the upstream change) - The environment was stabilized by pinning the dependency and preserving reproducibility - An upstream issue was opened with a minimal reproduction and clear technical breakdown - An internal Jira ticket and fix branch were created with full context and reproduction steps - A pull request was opened upstream to actually fix the issue in the source project And that PR was recently merged. What stood out to me is not just that the bug was found faster — but that the entire workflow from: failure → root cause → reproduction → fix → upstream contribution was effectively compressed into a single automated loop. Without AI assistance, this would have taken magnitudes more time. Realistically, it likely would have been “fix internally and move on”, because the cost of full investigation + upstream contribution is often too high for production urgency. Here, the low marginal cost of investigation changed that equation completely. A few reflections: - Debugging is increasingly becoming a systems + automation problem, not just a manual one - The biggest unlock is not “finding answers faster,” but closing the entire loop (including upstream fixes) - AI doesn’t just accelerate engineering work — it can make previously “too expensive to contribute back” workflows practical Curious how others are starting to see similar end-to-end automation loops emerge in their workflows. https://lnkd.in/dtK9AHTW

We had a small tool break this month, one that quietly prepared a file for a business partner every month, on a deadline that mattered. Nobody currently on my team wrote it. The person who did left a while ago. It had been doing its job fine for months, then a vendor changed a data format and it just stopped. No bug to fix. Just a black box that used to work. The honest answer I gave the business partner asking when it'd be fixed was: I don't know yet, because I don't fully know how it worked in the first place. Here's the thing I keep sitting with. I was exactly this kind of engineer for a decade. I hated writing documentation. The code was right there, why would I write a paragraph explaining what fifteen lines already said? I told myself the understanding lived in the code, and if you couldn't read the code, that was a you problem. I was wrong, obviously, this tool is proof of that. But I used to think the cost of being wrong was bounded. Worst case, someone senior enough could always crack the code open and figure it out eventually, because a human had written every line of it on purpose. That assumption doesn't hold the same way anymore. A real chunk of the code on my teams now gets scaffolded or heavily assisted by AI. It ships fast, it usually works, and increasingly the person who "wrote" it accepted more than they authored. They reviewed it, but they didn't reason through every line the way you do staring at a blank file. So the bus-factor-of-one problem I used to worry about, one person understands this and only one, is quietly becoming a bus-factor-of-zero problem. Nobody fully understands it. Not even the person whose name is on the commit. I've seen this before, but it's usually a system that grew large and complex over years until no one person could hold the whole thing. I'm watching that same collapse happen in months now, sometimes on code that isn't even large yet. I don't have a clean framework for this yet. But I know the old excuse, the code speaks for itself, why document it, was already weak. It just got weaker. Documentation isn't overhead anymore. It might be the only place understanding actually gets built now, instead of just captured.

6 agent experiments in 2 weeks. Same agent, measured each time. Here's the plan. The current build runs on a raw anthropic client with a hand-rolled while loop - eval-first from day one, with a CI/CD gate that blocks any prompt change that drops the score. No framework, just the API directly. Now I'm running it through 5 frameworks and one portability experiment to find out what each abstraction level actually costs. Week 1 - Claude Agent SDK - skills, hooks, and HITL as SDK primitives - LangGraph - draw the graph yourself; checkpointing as a first-class feature - LangChain create_agent() - prebuilt middleware, no graph ownership Week 2 - Deep Agents - loop fully hidden; native skills; find the ceiling - Google ADK - cross-provider benchmark with the same eval set - Cross-provider skills via MCP - one skill, three providers, what breaks in translation Same agent. Same tools. Same eval set across all six. Each post will have real numbers: test counts, boilerplate deltas, eval pass rates. Which framework would you add to this list - and what would you want to see measured? - Part of my series building Conductor, an AI agent for data integration.

Five tools, huh. The usual: glue a few APIs together, call it an agent. Practical, but brace for one misbehaving tool wrecking the whole flow. Nice that they cover compression-on-return and wiring choices – actually useful stuff for when you’re debugging at 2am. Still, expect weird edge-case failures and blame to land on the orchestrator. ¯\\_\(ツ\)\_/¯