✳ AI-Driven SDLC

An AI-native SDLC.
Slack-centric. Human-in-the-loop.

Six AI personas live inside the Slack channels where work already happens — so the team never leaves the conversation to write a BRD, draft a PRD, design an architecture, or open a PR. Conversation, decisions, and code, all in one place. AI does the drafting. Humans do the deciding.

Business Owner Product Owner Technical Architect Developer PR Reviewer Release Engineer

✳ What AI adds to how we already work

Remove the drafting. Keep the deciding.

AI does

The drafting

Writes BRDs & formats PRDs

Hunts Confluence for existing work

Writes boilerplate & test scaffolding

Drafts the PR description

Keeps Jira, GitHub & docs in sync

surfaces context

sends decisions

You do

The deciding

Make the judgment calls

Answer the questions asked

One decision frame per channel

Approve at every gate

Faster requirements

Questions answered async in Slack instead of meeting cycles.

Faster review

First pass done by the agent; humans focus on judgment calls.

Complete audit trail

Every decision — by whom, when, why — in one continuous thread.

✳ The flow — overview · click a persona

Six personas, handed off across channels, gated by humans.

✳ What it feels like in practice

Post a rough idea. Minutes later, researched context and sharp questions.

The kickoff — and the agent's first reply

PO

Product Owner just now

We want to add a per-type setting so certain checklist tasks can't be closed manually — only automation should complete them.

C

Cursor APP 3 min later already researched

Found 2 related items already in flight — a draft PRD covering the same config surface, and an adjacent routing spec. Linked below.

The config table for these task types already has an auto-close flag — a "block manual close" toggle would slot in on the same record.

Sources: Related PRD (Confluence) · TaskTypeConfig table

A few questions before I draft the BRD:

1. Per-type toggle, or all-or-nothing for any task with auto-close?
2. Should admins be able to bypass the lock?
3. Retroactive cleanup of already-open tasks, or forward-looking only?

Cross-system awareness with no extra effort — the agent read the codebase and found the in-flight work a human might have missed for weeks.

Answering is tapping choices, not writing essays

Tap an option, optionally add a note. Decisions, not blank-page paragraphs. The same interview pattern runs across every persona.

✳ Under the hood — how it's wired

Triggers fire agents. Agents reach out through real tools.

Triggers

6 Slack channels one per persona GitHub webhooks + labels post-code handoffs

↓

Cursor Cloud Agents — the heart of the system

Business Owner Product Owner Architect Developer PR Reviewer Release Engineer

.cursor/
├── rules/*.mdc persona prompts
└── skills/ templates + scripts
— version-controlled with the code —

↓

MCP Tools — reach into the real toolchain

Atlassian

Jira tickets · Confluence docs

GitHub

PRs · labels · files

Slack

channels · threads · posts

Prompts are code. Persona rules and skills live in the repo — changes ship through the same PR review pipeline as everything else.

✳ Field notes — from running it in production 1 of 4

One thread turns software delivery into a multiplayer game.

# project-room · one shared thread

PLDEVREVOPS

Shared objective: ship togetherOne conversation · one artifact trail · one durable agent session

● SHARED STATE

PL

IDEA

Product LeadFrames the problem and makes the product call.

move 01

DEV

BUILD

DeveloperPicks up the same context and turns it into code.

move 02

REV

REVIEW

ReviewerSees every decision and checks the work in place.

move 03

OPS

SHIP

Release EngineerValidates and ships without asking for a recap.

move 04

AI

SYNC

Cursor agentKeeps the board, context, and next move visible to everyone.

always on

Pixel-art software team collaborating around a giant shared Slack thread table

CO-OP SOFTWARE SESSION · 4 PLAYERS

Shared AI assistanceEveryone sees the same board.
Anyone can make the next move.

Work is visible to the whole party

Join mid-task without a recap

The thread preserves shared memory

Collaboration feels active and fun

✳ Field notes — from running it in production 2 of 4

One approved plan fixed the incident — and the class of incidents.

# release-engineering

Thread on sandbox validation · condensed

Cursor RELEASE AGENT2:15 AMDEPLOY BLOCKED

The PR code compiled. Validation is failing on environment state the change does not touch.

✗ pre-existing email configuration failure
✗ coverage drift in unrelated classesDiagnosis: sandbox drift — sync affected classes from the main source of truth.

Engineer 2:24 AM

“Sync the drifted classes from main into this sandbox.”

Cursor RELEASE AGENT2:26 AMPLAN · AWAITING APPROVAL

1 · Correct nowSync drifted classes and re-validate.

2 · Retain the patternWrite detection + recovery as a skill.

Sandbox only · no live communications · never mutate main · wait for approval

Engineer 2:29 AMAPPROVED

Execute the plan.

approved plan
became capability

3:22 AM · EXECUTION RECEIPT

The correction worked. Cursor retained it.

Mainsource of truth

Sandbox6 classes synced

.cursor/skills/release-engineer/
└── sandbox-drift-sync/
├── SKILL.md
└── scripts/{detect-drift, sync-from-main}.sh
release-engineer.mdc + AGENTS.md updated

72 / 72 components deployed

Original PR merged

Reusable skill submitted for review

What changed afterwardAutomatic cutoff at four

Attempt 1verify + fix

→

Attempt 2retry with evidence

→

Attempt 3last auto retry

→

Attempt 4 · STOPraise for human review

The human solved the exception. The system retained the pattern.

✳ Field notes — from running it in production 3 of 4

Prompts as code — the whole agent system lives in Git.

agent-control-plane/.cursortree · source of truth

Rules · agent identities

.cursor/rules/
├── business-owner.mdc  ← Business Owner prompt
├── product-owner.mdc   ← Product Owner prompt
├── architect.mdc       ← Architect prompt
├── developer.mdc       ← Developer prompt
├── pr-reviewer.mdc     ← Reviewer prompt
└── release-engineer.mdc ← Release prompt

Skills · reusable capabilities

.cursor/skills/
├── business-owner/
│   └── brd-generation/  SKILL.md · template
├── product-owner/
│   └── prd-generation/  SKILL.md · template
├── architect/
│   ├── architecture-options/  SKILL.md
│   └── implementation-plan/  SKILL.md · template
├── pr-reviewer/
│   └── code-quality-review/  SKILL.md
└── release-engineer/
    └── sandbox-drift-sync/ ← NEW · agent-authored
        ├── SKILL.md
        └── scripts/  detect · recover

AGENTS.mdcross-cutting policies · repository-wide behavior

How experience becomes behavior

Observe

A real run exposes a repeatable lesson.

Codify

Update a rule or add a versioned skill.

Review

Diff → reviewer agent → human gate.

Reload

Merged behavior becomes the next run's default.

Persona prompts are files

Six personas · six `.mdc` files · one per channel

Skills are organized capabilities

`SKILL.md` plus scripts, templates, and references

Behavior changes ship like code

Diffed · reviewed · approved · fully traceable

Humans and agents both improve it

`sandbox-drift-sync` is the proof

The system reviews its own improvements.The repository is both its source code and its institutional memory.

✳ Field notes — from running it in production 4 of 4

Good prompts start the work. Feedback loops prove it worked.

Inner loop · this change

Does the pull request actually work?

execution evidence

Bounded autonomyClean → human approval
Attempt 4 → human review

Issues

Outer loop · every future change

What should the next run know?

durable learning

Repository memoryversioned · reviewable
reversible

System does

Human role

Evidence / memory

The inner loop proves this change. The outer loop improves the next one.Click any step to walk the loop

Framing: Daniel Demmel · Warp

✳ The takeaways

Four properties make the system trustworthy.

01 · DIVISION OF LABOR

DRAFT

AI drafts. Humans decide.

Documents, code, and tests are generated quickly. Every consequential decision still ends at a human gate.

02 · DEFENSE IN DEPTH

CHECK

The system catches its own work.

RED TEAMSCANSSANDBOX

Architecture critique, code/security review, and environment validation catch different classes of failure.

03 · COMPOUNDING MEMORY

LEARN

Every blocker becomes a capability.

CODIFY

SKILL.md
detect.sh
recover.sh

Novel recovery knowledge is captured as versioned skills, so the next occurrence is cheaper than the first.

04 · INSPECTABLE EVIDENCE

VERIFY

Trust is easier when evidence is inspectable.

Agent claim“This path already exists.”

Sourcefile · line · commit

verified

Citations, linked artifacts, git history, and execution logs make claims independently checkable.

We automated the friction — not the judgment.Judgment · taste · accountability stay human

✳ Appendix · optional deep dive

Persona workflows.
Role by role.

Detailed interactive maps for the Business Owner, Product Owner, Technical Architect, and automated post-code pipeline. Use these during Q&A when the audience wants to inspect a specific stage.

Business Owner Product Owner Technical Architect Post-code Machine

✳ Appendix · persona flow · click a phase Business Owner

Business Owner

Agent does

You do

Result

Raw notes in

AK"Certain checklist tasks shouldn't be closable by hand — only automation."

Decisions needed

Per-type toggle

All auto-close tasks

Fixed list

BRD written

Business Requirements

9 sections · on Confluence

Epic TICKET-123

Handed off

posted to

#sdlc-product-owner

Click each phase above — the artifact it produces highlights below.

✳ Appendix · persona flow · click a phase Product Owner

Product Owner

Agent does

You do

Result

BRD received

Business Requirements

linked from BO handoff

Reads it, spots the gaps.

Scope & sizing

Dual-axis sizing locked:

Effort · M Risk · Med

PRD written

Product Requirements

on Confluence

ACsNFRsMust-Not-Change

Handed off

posted to

#sdlc-architect

The Effort × Risk sizing set here drives the architect's review depth — FFS-Lite or full FFS.

✳ Appendix · persona flow · click a node Technical Architect

Technical Architect

✳ Appendix · post-code pipeline · click a node State Machine

An AI-native SDLC.Slack-centric. Human-in-the-loop.

Remove the drafting. Keep the deciding.

Six personas, handed off across channels, gated by humans.

Post a rough idea. Minutes later, researched context and sharp questions.

The kickoff — and the agent's first reply

Answering is tapping choices, not writing essays

Triggers fire agents. Agents reach out through real tools.

One thread turns software delivery into a multiplayer game.

One approved plan fixed the incident — and the class of incidents.

The correction worked. Cursor retained it.

Prompts as code — the whole agent system lives in Git.

Good prompts start the work. Feedback loops prove it worked.

Does the pull request actually work?

What should the next run know?

Four properties make the system trustworthy.

Persona workflows.Role by role.

Business Owner

Product Owner

Technical Architect

After the architect handoff — the app drives everything.

An AI-native SDLC.
Slack-centric. Human-in-the-loop.

Persona workflows.
Role by role.