How Our Gradient CRM Improves Itself Overnight Using Claude Code Routines

TL;DR: We built our own CRM at Gradient, with a feedback tab built directly into the product. Each night, we run two Claude Code routines: one that turns product feedback into code changes, and one that syncs activity from email, calendars, and Granola so our contacts stay current. The key: our CRM continually improves, while daytime AI usage is reserved for customer-facing work.

This is a small example of how we try to build Gradient: use AI on real internal workflows, keep humans in the loop where judgment matters, and let the system improve through use.

Why we built our own CRM

One of the first things any company needs is a CRM, or customer relationship management system, to track the people and companies you are building relationships with.

At Gradient, our first CRM was the ever-adaptable Google Sheet. That worked for a while: it's a shared source of truth and it's easy to edit.

Over time, though, we realized we wanted more flexibility to keep track of multi-step outreach, map the relationships between companies and contacts, and use AI to enrich outreach in ways that were specific to us.

For example: has this person worked with one of our investors, attended our alma mater, used a tool we integrate with, or written publicly about AI fluency?

We looked at third-party options. Many of them were expensive, required sales conversations to set up, or still required our team to patch together several systems: Clay or Apollo for enrichment, HubSpot or Salesforce for CRM, and a custom integration for our product signals.

Instead, we decided to build Gradient Admin, an internal portal that combines CRM, product analytics, and operational workflows in one place.

This is not because every startup should build its own CRM. We might outgrow our homegrown CRM over time. But we decided to start out this way because our CRM is also a lab for how we work with AI: structured data, human judgment, feedback loops, and operational tools that get better with use.

The feedback tab that closes the loop

Once Gradient Admin was useful, we started using it every day.

We started noticing small 'papercuts' - little issues that we wanted to improve: an awkward filter, an edge case, workflow that took six clicks when it should have taken two.

None of these issues were individually worth derailing focus away from outreach or product work, but they were things we wanted to fix.

So we came up with a solution: we added a feedback tab directly into Gradient Admin.

When someone on the team hits friction, they can describe the issue in the product itself and log their feedback. The team's responsibility is to provide enough context - make their feedback specific enough - for it to be actionable.

Then, instead of asking a founder or engineer to triage every small improvement during the day, we let the system process the queue overnight.

Processing product feedback overnight

Each night, a Claude Code routine reviews the feedback queue and turns it into implementation work.

At a high level, the routine does five things:

1. Groups related feedback into coherent tasks.
2. Checks the codebase to understand the relevant UI, API route, or database contract.
3. Makes a focused change for each issue.
4. Runs the available checks, including visual QA for UI changes.
5. Opens a pull request with a summary of what changed and what was verified.

The routine has scoped access to the tools it needs: GitHub, the repository, and infrastructure context like our Supabase database. We use a lower-cost model for this class of work because the tasks are usually bounded and low-sensitivity.

This works especially well because Gradient Admin is an internal surface. If something breaks, the blast radius is small. We can roll back the PR, fix the regression, and move on. That makes it a good place to be more aggressive with automation while still keeping human review and observability in the loop.

The result is simple: we wake up to pull requests that fix yesterday's papercuts.

Updating contacts and accounts overnight

The second nightly routine keeps the CRM current.

One of the hardest parts of CRM hygiene is that the important context rarely starts inside the CRM. It lives across emails, calendar events, meeting notes, and follow-ups.

If the team has to manually copy all of that into a system, the system will drift. If the system drifts, people stop trusting it.

So each night, we sync activity from the tools where relationship context already exists:

1. Email threads that show recent conversations.
2. Calendar events that show meetings, introductions, and follow-ups.
3. Granola notes that capture what actually happened in calls.
4. CRM records that need updated statuses, next steps, or relationship notes.

The routine does not treat every artifact as equally important. It looks for useful signals: a new stakeholder, a changed company priority, a promised follow-up, a hiring need, a product concern, or an upcoming decision point.

Then it updates the relevant contacts and accounts in Gradient Admin so the CRM reflects what the team actually knows.

This is the kind of workflow that is easy to describe and annoying to maintain manually. It is also exactly the kind of workflow where AI helps: synthesize messy context, propose structured updates, and keep the human-facing system fresh.

What we have learned

The main lesson is that AI-native company building is less about one big dramatic agent and more about many small loops.

A few principles we expect to reuse from Gradient Admin:

1. Make feedback easy to give where the work already happens.
2. Run bounded automation on low-sensitivity surfaces first.
3. Teach the team to provide context upfront and keep tasks discrete.
4. Keep humans in the loop for review, taste, and judgment.
5. Let internal tools become practice fields for how the company wants to work externally.

The last point is the key here. At Gradient, we help companies hire AI-fluent talent through real-work assessments. Candidates complete take-home projects inside an AI-powered sandbox, and hiring teams can review both the final deliverable and the process behind it.

We believe AI fluency is not just whether someone can prompt a model. It is whether they can break down ambiguous work, use the right tools, evaluate outputs, preserve judgment, and create leverage in a real workflow.

We try to hold ourselves to the same standard.

Why this matters for Gradient

Our mission is to help people and teams grow their AI fluency. That means we need to build the company in the same direction as the product.

Gradient Admin improving itself overnight is not the whole story. It is one operating loop. But it captures the kind of company we are trying to build: practical, experimental, and willing to use new AI techniques where they create real leverage.

If you are curious about Gradient Admin, AI-fluent hiring, or how your team can build more fluency into everyday work, we would love to talk.