Back to database

Steve Kaliski, Stripe's AI use case

Engineer at Stripe

Helped build Stripe Minions, an internal AI coding-agent workflow where employees can trigger agents from Slack, have them make code changes, and review the resulting pull requests before anything ships.

The problem

What was broken before AI

Many engineering tasks are small enough to be annoying but still require context: fixing copy, updating documentation, changing a configuration, adding a small feature, or making a routine code adjustment. The work is not always hard, but it still interrupts someone, requires switching tools, and competes with higher-priority engineering time. At a large company, those small requests can pile up across teams.

What changed

What the use case made possible

Stripe Minions moves the first step of that work into Slack. A teammate can trigger an agent from the conversation where the need appears. The agent uses coding tools to make the change and then opens a pull request. That keeps the workflow lightweight for the person making the request, while preserving the engineering review process that makes the result safer to accept.

Why this matters

Why this use case is worth studying

Steve’s use case is useful because it shows AI agents fitting into an existing team workflow instead of replacing it. The agent does the first pass. Slack provides the front door. GitHub-style review provides the guardrail. That combination matters: the team gets leverage from AI without pretending the model should make final decisions on its own.

Use this when

When this pattern applies

Use this pattern when small engineering requests already appear in chat and frequently interrupt the people who know how to make the change. It works best for narrow, reviewable tasks where an agent can prepare a first draft but a human should still approve the final result.

Exponential Builder analysis

01

Put agents at the point of interruption.

Stripe Minions works because the handoff starts in Slack, where many small engineering requests already appear, which reduces the cost of turning a conversation into action.

02

Make the agent produce something reviewable.

The useful unit of work here is a pull request, because it gives the team a concrete artifact to inspect, discuss, and reject if needed.

03

Scale by task class, not by ambition.

The safest expansion path is to find repeatable small changes, learn where the agent succeeds or fails, then widen the scope only after the review loop is reliable.

Who this is for

Best fit

Engineering teams with lots of small internal requests

Platform and internal tools teams

Developer productivity teams

Teams already coordinating work in Slack

Organizations experimenting with AI coding agents

Teams that want agent leverage without removing human review

What to avoid

Mistakes and warnings

Where this pattern can go wrong if you copy it too literally.

Do not let agents bypass code review.

Avoid starting with broad or risky code changes.

Keep permissions narrow until the team understands failure modes.

Make the agent ask for clarification when the request is ambiguous.

Watch for teams treating generated PRs as automatically correct because they came through a familiar workflow.

Public workflow preview

The shape of the workflow

A high-level look at how the use case works, with the reusable pattern made clear.

01

Put the agent where requests already happen

Instead of making people open a separate tool, Stripe Minions starts from Slack.

02

Make the trigger lightweight

A message or emoji can become the handoff point from human request to coding agent.

03

Let the agent do the first pass

The agent reads the request, works through the code change, and prepares a pull request.

04

Keep review in the normal workflow

Humans still inspect the PR before it becomes part of the codebase.

05

Expand only where the pattern works

Once the team trusts a class of tasks, more small requests can move through the same agent pathway.

Copy the pattern

The reusable idea

Pattern in one sentence

Move first-pass coding work into the team’s existing chat workflow, but keep the final decision inside the normal review process.

Reusable idea

Steve’s workflow is a good reminder that AI agents do not need a brand-new interface to be useful. Often, the best place to start is the conversation where work already begins. If a team repeatedly turns Slack threads into small code changes, documentation updates, or operational tasks, an agent can take the first pass while the team keeps the same review standards it already trusts.

Steal this workflow

Use this for recurring engineering requests that begin in chat:

1

Pick one narrow request category: docs fixes, UI copy changes, internal tooling tweaks, or routine configuration updates.

2

Define the Slack handoff: a command, emoji, or short message that clearly assigns the task to the agent.

3

Give the agent boundaries: target repo, allowed task type, expected size of change, and when to ask for clarification.

4

Require a pull request every time: no direct commits, no automatic shipping.

5

Standardize the PR body: summary, reason for change, files touched, and reviewer checklist.

6

Assign a human owner for approval.

7

Track outcomes: accepted as-is, revised, rejected, ambiguous request, permission issue, or risky change.

8

Expand only after one category shows a reliable pattern.

Suggested prompt

“Turn this Slack request into a minimal, reviewable code change. First, restate the request and identify any ambiguity. Inspect the relevant files, make only the smallest safe update, and open a pull request. In the PR description, include what changed, why it changed, which files were touched, and what the reviewer should check. If the request is unclear, broad, or touches risky areas, stop and ask for clarification instead of making the change.”

Field notes

Get new AI use cases in your inbox

A short weekly note on how real people are using AI to save time, make money, build tools, and run their lives.

No spam. Just useful AI use cases.

Related use cases

Keep exploring nearby systems.

Browse all