Pipelines are the new git hooks
Git hooks automated commits. CI/CD automated deployment. Agent pipelines automate development itself. We're automating the first mile.
A brief, incomplete history of dev automation
2005: You write a pre-commit hook that runs ESLint. It catches a trailing semicolon. You feel like a wizard.
2013: You set up Jenkins. It builds your project on every push. It breaks constantly, but when it works, it's beautiful. Deployment goes from "SSH into the server and pray" to "merge to main and walk away."
2019: GitHub Actions. Now your CI/CD lives in a YAML file next to your code. Tests, builds, deploys. The last mile of software delivery is fully automated.
2026: Agent pipelines. And I think they're going to be just as standard as CI/CD within two years.
Hot take? Maybe. But hear me out.
The pattern repeats
Every wave of dev tooling automation follows the same arc. Someone gets tired of doing a repetitive task manually. They write a script. The script becomes a tool. The tool becomes infrastructure. Then everyone forgets there was ever a manual step.
Nobody manually FTPs files to a server anymore. That's what CI/CD killed. But we still manually open our editors, read through tickets, write implementation code, run tests, fix what breaks, and push. Every single day.
That's the first mile. And it's still manual.
Git hooks were the beginning
Think about what a git hook actually does. It intercepts a moment in your workflow (committing, pushing, merging) and runs automated logic. Pre-commit hooks lint your code. Pre-push hooks run tests. Post-merge hooks install dependencies.
The key insight: git hooks don't replace the developer. They augment a specific moment in the workflow. You still write the code. The hook just catches your mistakes before they land.
Agent pipelines do the same thing, but for the part before the commit even exists.
Pre-check, implement, validate is the new lint, commit, push
I've been running the NightLoop pipeline pattern for over a year now, and I keep coming back to how structurally similar it is to the git hook flow.
Git hooks: lint the code, commit, push. Each step is automated, sequential, and has failure handling (if lint fails, commit is blocked).
NightLoop: pre-check the codebase, implement the feature, validate the output. Each step is automated, sequential, and has failure handling (if validate fails, retry kicks in).
The shape is identical. The scope is different.
Git hooks operate on code you already wrote. Agent pipelines operate on code that doesn't exist yet. That's the shift. We moved from automating quality checks on human output to automating the output itself.
We automated the last mile. Now it's the first.
Here's how I think about it. Software delivery has two ends.
The last mile: code is written, now get it tested, built, and deployed. CI/CD solved this. It's basically a solved problem. GitHub Actions, CircleCI, Vercel, Netlify. Pick one, configure it, forget about it.
The first mile: a ticket exists, now turn it into working code. This was untouched until agents got good enough to actually write code. And even then, running a single agent on a single task is like running a single test manually. It works, but it doesn't scale.
Pipelines are what make the first mile scalable. Load 15 tasks. Define the execution order. Set retry logic. Hit play. That's the first-mile equivalent of git push triggering your entire CI/CD chain.
My "aha" moment
I remember the exact night this clicked for me. I was at home, it was maybe 1am, and I was manually babysitting Claude through a set of refactoring tasks. Checking the logs, jumping into the code to fix a dumb import, updating Claude's context so it wouldn't repeat the same mistake, then moving to the next task. For three hours.
I stopped and thought: I'm not even coding. I'm project-managing an agent one task at a time. This is the same thing I used to do with deployments before CI/CD. I used to SSH into a server, run the build command, watch the output, fix something, run it again. Then Jenkins came along and I never did that again.
Why was I still doing this with agent tasks?
I wrote the first version of nightloop.sh that night. Three bash functions. Pre-check, implement, validate with a retry loop. Went to bed. Woke up to 4 completed tasks out of 6. Not perfect, but I didn't have to context-switch between tasks manually for three hours.
That was the moment I knew pipelines were the abstraction layer agents were missing.
The config file prediction
Here's my spicy prediction: within two years, most serious projects will have a pipeline config file sitting next to their .github/workflows directory. Something like .zowl/pipelines/ or whatever the ecosystem settles on.
It'll define default agent behavior for that repo. What to scan during pre-check. What tests to run during validation. How many retries. Which directories are off-limits. Token budgets.
Just like .eslintrc standardized linting config and ci.yml standardized build config, pipeline configs will standardize how agents interact with your codebase.
Nah, I don't think this is optional. I think it's inevitable.
Projects without CI/CD already feel broken. Five years from now, projects without agent pipeline configs will feel the same way. You'll clone a repo, see there's no pipeline config, and think "how does this team even ship?"
Why most people don't see this yet
CI/CD took about 5 years to go from "neat idea" to "you're irresponsible if you don't have it." Agent pipelines are at year one of that curve.
Right now, most devs interact with agents one task at a time. One chat window, one question, one response. That's the equivalent of manually running your test suite in a terminal. It works. It's just not the right abstraction.
The right abstraction is the pipeline: a defined sequence of automated steps that turns input (a task description) into output (a PR ready for review), with error handling and observability built in.
Some devs get this immediately. They're the same ones who set up Jenkins in 2013 when their teammates were still doing manual deployments. Early adopters see the pattern because they've seen it before.
This isn't about replacing developers
I want to be clear because this conversation gets weird fast. Agent pipelines don't replace developers any more than CI/CD replaced ops engineers. Ops engineers still exist. They just stopped manually deploying on Friday afternoons.
Developers will still exist. They'll just stop manually shepherding every single code change through implementation. They'll define pipelines, write PRDs, review output, and focus on the parts of building software that actually require human judgment (architecture, UX decisions, tradeoffs, talking to users).
The mechanical parts? The "read the ticket, open the file, write the boilerplate, run the tests, fix the typo, run the tests again" loop? That's pipeline work.
Where Zowl fits
I built Zowl because I needed a pipeline runner for agents. Not a chatbot. Not an IDE plugin. A pipeline runner.
The same way GitHub Actions is a pipeline runner for CI/CD, Zowl is a pipeline runner for agent tasks. It handles sequencing, retries, context passing, observability, and overnight execution. The NightLoop template (pre-check, implement, validate) ships as a default because that pattern covers most coding work.
But it's just the default template. You can build whatever pipeline shape your project needs.
The era of babysitting agents one task at a time is ending. The era of pipelines is starting. And honestly, it was always going to happen this way. Automation never stops at the last mile.