# Research Development Life Cycle

v1.4.3 | updated 2026-07-31 | [CHANGELOG](./CHANGELOG.md)

A product design and research methodology, packaged as an agent skill.
Research Development Life Cycle (RDLC) governs everything from the first signal to a validated design:
sensing problems in your research corpus, discovery, design definition,
ideation, prototyping, and human validation. Its terminal artifact, the
**Validated Intent**, is the input handed to whichever engineering process
builds it next.

> AI proposes, humans decide. Evidence before opinion. Failure paths before
> happy paths.

Questions adapt to the host: capable terminal interfaces use arrow-key
selection and Enter, desktop interfaces use option buttons, and every question
still accepts a selected option plus context or a fully open-ended answer.

## Phase map

```
SIGNALS ─► DISCOVERY ─► DEFINITION ─► DESIGN ─► VALIDATION ─► [engineering] ─► OPERATIONS
(mine the  (is it real,  (mental      CONSTRUCTION (trust      Inception →   (post-ship
 corpus)    is AI right)  model,       (prototype    scorecard,  Construction  listening,
                          failure       loops, HAX   ship gate)  → Operations  feeds SIGNALS)
                          modes)        checks)
```

## Start in any AI app

Open ChatGPT, Claude, Gemini, or another AI app with web access and paste:

```text
Fetch and follow RDLC Conversation Mode at
https://rdlc.org/rdlc-rules/chat-workflow.md.

Help our team decide what product work is worth doing. Work in this chat. Do
not ask us to install anything or use a command line. Ask one
decision-shaping question at a time and keep a compact RDLC Working Record.

Our situation:
[Describe the product idea, research, prototype, or decision.]
```

Conversation Mode keeps evidence, assumptions, decisions, risks, conflicts,
and the next action in one copyable Working Record. If the AI app cannot fetch
a URL, use the "Copy with the method" button at https://rdlc.org.

## Workspace setup

Use this path when a coding agent should write persistent, versioned RDLC
artifacts into a repository.

```bash
git clone <this-repo> aidlc-design-workflows
cd your-project

# install steering rules for your agent (claude | cursor | copilot | cline | kiro | q | agents)
../aidlc-design-workflows/scripts/setup.sh claude

# feed the corpus (de-identified!) then inventory it
cp ~/exports/*.csv research-corpus/support-tickets/
python3 scripts/corpus/ingest.py
```

Then start your agent and say:

```
Using RDLC signals, mine the research corpus and surface our top unframed problems.
```

or, with a problem in hand:

```
Using RDLC, help us decide whether to build <thing>.
```

Trigger phrases: `Using RDLC, ...` (adaptive) plus phase jumps:
`signals` / `discovery` / `define` / `prototype` / `validate` / `listen` / `kb`.

## What it enforces

- **Risk tiers (T1 regulatory → T4 internal)** scale every gate. Payments and
  personal-data work cannot skip validation; internal tools ship fast.
- **Mental model before pixels.** No prototyping until the user's mental model
  of the AI is written and approved.
- **Failure before happy path.** Wrong-AI states are designed first; every
  validation study includes a mandatory failure-recovery task.
- **Trust Scorecard ship gate.** Comprehension, Control, Failure Recovery,
  Trust Delta, with thresholds by tier. Engineering KPIs measure whether the
  software works; this measures whether humans trust it.
- **AI necessity test.** Sometimes the right answer is a better form, not a
  model. The workflow says so.
- **Two working modes.** Conversation Mode works inside an ordinary AI chat
  with no install. Workspace Mode writes persistent project artifacts for
  resume, handoff, and version control.
- **A living knowledge base.** In Workspace Mode, `rdlc-docs/kb/` holds business context,
  market context, personas, a value map, numbered learnings, decisions, and
  conflicts. Every phase gate ends with a mandatory KB sync; freshness sweeps
  flag stale personas; nothing is approved with un-synced learnings.
- **Strategist lens.** Elicitation banks interrogate the business, the users,
  and the market; every intent must state user value, business value, and the
  causal linkage between them. A "hopeful" linkage blocks T1/T2 ship gates.
- **Conflict and challenge protocol.** Contradictions between artifacts, KB
  entries, and evidence are detected at gates and logged as C-NNN with forced
  resolution. Unexamined assumptions get exactly one plain challenge; the
  user's decision is then logged with the overruled evidence.
- **Design Units of Work.** Work splits by the question it answers, one owner
  each, with interface contracts, crit rituals that cite principles by number,
  and calibration from solo designer to multi-squad teams.
- **Session continuity, handoff, and splitting.** A live `state/` folder
  (resume.md, an append-only session log, per-unit worklogs with OPEN THREADS)
  lets any designer or a fresh agent resume cold, take over a unit, or split
  work in parallel, with no synchronous handoff meeting required. `Using
  RDLC resume` / `handoff DUW-NN to <name>` / `split <phase>`.
- **Prototype construction, grounded in real solutions.** CONSTRUCTION starts
  by asking where the prototype begins (green field, existing Figma, live
  page, repo, or a Chrome-extension emulation of a live product) and whether
  a design system exists. It reviews every loop live via Chrome MCP, citing
  named UX laws and design principles rather than unattributed taste, debates
  genuine tensions explicitly instead of resolving them silently, and gives an
  explicit READY / NOT READY verdict before entering VALIDATION. Loop-backs
  from VALIDATION re-enter as scoped iterations grounded in what specifically
  failed. See `common/ux-laws.md` and `docs/CHROME-MCP-SETUP.md`.
- **External research on demand.** When an idea or thin-market problem is on
  the table, RDLC offers competitive analysis, market and category scans,
  recent news, analogous patterns, and regulation/capability context, and runs
  it (if a search tool is available) only when you say yes. Findings enter the
  KB as sourced, numbered learnings, never as unattributed confidence.
- **The 5 Universal AI Agents.** Research Synthesizer, Competitor
  Intelligence, Problem Definition, Idea Generation, and UX Flow Designer
  (Nick Babich, "Agentic Product Design," UX Planet) map directly onto
  RDLC's SIGNALS/DISCOVERY, external-research, DISCOVERY, IDEATION, and
  DEFINITION stages, contributing named failure-mode checks, a friction-type
  taxonomy, and explicit human-in-the-loop boundaries at each. See
  `common/design-agents.md`.
- **A killed/ folder.** Stopping on evidence is logged as a success.

## NotebookLM / corpus mining

The SIGNALS phase mines a local `research-corpus/` (interviews, tickets, NPS
verbatims, sales notes, analytics) and can also mine NotebookLM / Gemini
Notebook directly. Three paths, detailed in docs/NOTEBOOKLM-INTEGRATION.md:
(A) live MCP via community servers such as notebooklm-mcp-cli, letting the
agent query notebooks with citations; (B) CLI batch pulls using the shipped
prompt files; (C) manual export of the four mining prompts. There is no
official consumer API yet (Enterprise API exists via Google Cloud), and Paths
A/B use unofficial cookie-auth tooling, so the doc includes a data-governance
gate: NDA'd or personal material goes through security review or stays
on Path C. All mined answers land in `research-corpus/notebooklm-exports/`
so evidence stays file-based, git-audited, and PII-free.

## Repo layout

```
rdlc-rules/
  core-workflow.md         # the steering file agents load
rdlc-rule-details/  # lazily loaded per-phase rules
  common/                  # risk tiers, principles, KB, conflict protocol,
                           # strategist lens, work units, session continuity
  signals/  discovery/  definition/
  design-construction/  validation/  operations/
  signals/prompts/         # NotebookLM/CLI mining prompt files
  extensions/              # payments-risk, personal-data-trust (opt-in, blocking),
                           # accessibility (always on)
scripts/
  setup.sh                 # installs rules for claude/cursor/copilot/cline/kiro/q
  corpus/ingest.py         # normalizes + inventories the corpus
research-corpus/           # your evidence goes here (de-identified)
docs/                      # artifact reference, working guide, NotebookLM setup

# generated at runtime in your project:
rdlc-docs/
  kb/                      # living knowledge base
  state/                   # resume.md, session-log.md, worklog/  <- resume & handoff
  signals/ discovery/ definition/ ideation/ design-construction/ validation/ operations/
  plan/ questions/ killed/ for-engineering/
```

## Extensions

Same mechanism as engineering: `*.opt-in.md` files present a question during
Problem Framing; enabled extensions become blocking rules with verification
criteria (PAY-01..04, PDT-01..04, A11Y-01..03). Add your own by dropping a
rules file + opt-in file into `extensions/<category>/`.

## Relationship to engineering

| | engineering | RDLC |
|---|---|---|
| Question | Are we building it right? | Are we building the right thing? |
| Cadence | Bolts | Prototype loops |
| Collaboration ritual | Mob Elaboration / Construction | Framing sessions, study reviews |
| KPIs | Deployment, recovery, defect metrics | Comprehension, Control, Trust Delta |
| Output | Working software | Validated Intent (engineering's input) |

During later engineering stages, run the reduced loop (HAX check + content review)
inside each Bolt for any Unit of Work with a user-facing surface.

## License

MIT-0, matching the upstream engineering workflows repo convention.
