The Builder and the Caretaker Are Not the Same Person

Automation tools now drop several a week. The day Cursor launched its Automations feature, I tried it next to Claude Code. My first guess was "this is just another version of Claude Code." After using both for a few days, it hit me — they aren't doing the same job at all. Their characters differ.

Let's unpack that difference from first principles. The point is not to compare two products. The point is why a single project needs two kinds of roles. That principle survives even when Cursor and Claude are both renamed. Slowly now.

Every project has two stages

Any project you build splits into two stages.

First, the build stage. You decide what to make, design it, and push the system into existence. This stage runs on judgment. "Is this feature right? Is this structure right? Is this direction right?" Questions crowd every minute. Creative, heavy on thought.

Second, the maintain stage. You keep what already runs from falling apart. This stage runs on repetition. You inspect on a schedule, catch errors the moment they appear, run security checks without missing a day. Less judgment, more consistency.

The two stages have opposite personalities. Building should not be boring. Maintaining should not be novel. That is why the same person rarely excels at both. Construction sites separate architects from site managers for the same reason.

AI tools are no different. The tool that builds well and the tool that maintains well are not the same.

An example — Claude Code and Cursor Automations

Let me show it concretely. Two tools today.

• Claude Code — an AI that runs in your terminal. Has full access to your local files. Coding, writing, email cleanup — give it any kind of task and it works. A general-purpose AI assistant.
• Cursor Automations — automation that runs in the cloud. Keeps going when your machine is off. Works only inside a GitHub repo, though. Code review, test execution, security checks. A code caretaker team.

At a glance they look similar: both are "AI touches code." Look closer and the positions diverge.

Claude Code shines on the build side. Designing new features, hopping across files to shape structure, solving problems it has never seen. Creative work with lots of judgment. This belongs in the local loop, rapid back-and-forth with a human.

Cursor Automations shines on the maintain side. Every time code lands on GitHub it reviews automatically. Every night it runs security. Errors get bounced back with a fix PR. High repetition, constant standard. It belongs in the cloud, running while you sleep.

An analogy — architect and building manager

Picture a house. When you first build it, who do you need? An architect. They read the land, draft plans, choose materials, supervise construction. The work is creative and judgment-heavy. Each decision differs.

Once the house is up? The architect doesn't stay to change lightbulbs and fix faucets. A building manager shows up. They inspect the same systems at the same time each day. They watch CCTV, run security rounds, file utility bills. The work is repetitive, and consistency is quality.

Make the architect do the manager's job and it goes wrong. They over-design a lightbulb change, or paint the hallway differently each week and confuse tenants. Flip it and the manager designing a new house? Freezes the moment creative judgment is needed.

Claude Code and Cursor Automations map exactly to this pair. Claude Code is the architect. Cursor Automations is the manager. Both needed, and the house runs best when they don't overlap.

The numbers

Here is the same-size project split between the two tools.

Item	Claude Code (building)	Cursor Automations (maintaining)
Environment	Local (needs your machine)	Cloud (machine off is fine)
Scope	Whole file system	Inside a GitHub repo
New feature design speed	Fast (human loop)	Slow (loops are hard to design)
Daily repeat checks	Painful (must stay on)	Automatic (sleeps through it)
Error handling	Ask the human	Sandbox retry on its own
Monthly operating load	Lots of human touch	Near zero after setup

The question "which one is better" is wrong. The right question is which stage. Build stage, Claude Code fits. Maintain stage, Cursor Automations fits. The same project eventually needs both.

One question splits each task

How to split in practice? One question.

"Is this task first-time or repetition?"

Two answers.

"First time" → architect tool

Designing a new feature. Laying out first-time structure. Tracing a hairy bug. Judging across many files. Reach for a local, conversational AI like Claude Code. Speed-loop with a human.

"Repetition" → caretaker tool

Checking already-built code to the same standard every time. Security scanning on each commit. Weekly dependency updates. Reach for a cloud automation like Cursor Automations. Must keep running while the human is off.

Three-word memory hook: First time architect. Repetition caretaker. Both needed.

A real flow — using both in one project

Here is how I actually stitch them together. A recent project of mine.

Stage one — build with Claude Code (two days)

Open Claude Code in the local terminal. "Add an auto-reply feature for comments. Read the existing structure and design to match." Claude scans files, proposes a design, writes code. Halfway through I say, "actually, a different approach might be better," and it pivots. Two days of hundreds of small loops, and the feature is done. This stage demands a tight human-AI rhythm.

Stage two — push to GitHub (ten minutes)

Once the feature is in, push to GitHub. From here we hand off to the caretaker.

Stage three — maintain with Cursor Automations (one-time setup)

In the Cursor dashboard, click New Automation. Trigger set to "GitHub Push." Prompt: "Review the code and flag security issues." Save. Done. Setup once, automatic from there. Every new commit gets reviewed, and issues land as PR comments.

The shape matters. Build local and fast with a human. Maintain cloud and steady, automatic. GitHub is the bridge between the two.

Summary

Let me pull the principle together.

Every project has a build stage and a maintain stage. Their personalities are opposites. Building runs on creativity and judgment. Maintaining runs on repetition and consistency. Force one tool to do both and neither gets done well. The instinct to match the tool to the role is what lasts.

The names Cursor and Claude might both change by next year. The principle holds. Hundreds of new AI automation tools will appear, and each will fall on one of two sides. Architect family or caretaker family. Master that sort and every new tool finds its place on arrival. Tools change. Roles don't.

Three words to close.

First time architect. Repetition caretaker. Repo is the bridge.