home / skills / coowoolf / insighthunt-skills / chatter-driven-development

chatter-driven-development skill

safe

/user-research/chatter-driven-development

This skill helps teams harness chatter-driven workflows by having AI proactively draft artifacts from conversations.

npx playbooks add skill coowoolf/insighthunt-skills --skill chatter-driven-development

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.2 KB

---
name: chatter-driven-development
description: Use when designing futuristic agentic workflows, when wanting AI to proactively act on team communications, or when eliminating the bottleneck of formal specifications
---

# Chatter-Driven Development

## Overview

A development paradigm where AI agents monitor unstructured team communications (Slack, Linear, meetings) to infer intent and **proactively generate code** without formal specifications.

**Core principle:** Use existing team "chatter" as input—discussions, complaints, questions—and let agents draft solutions before being asked.

## The Flow

```
┌─────────────────────────────────────────────────────────────────┐
│  1. SIGNAL INPUT                                                │
│     Slack messages, meeting transcripts, Reddit complaints      │
│                          │                                      │
│                          ▼                                      │
│  2. INTENT EXTRACTION                                           │
│     Agent parses chatter to identify:                           │
│     • Bugs    • Feature requests    • Questions                 │
│                          │                                      │
│                          ▼                                      │
│  3. PROACTIVE ARTIFACT GENERATION                               │
│     Agent drafts:                                                │
│     • Pull Requests    • Answers    • Analysis                  │
│                          │                                      │
│                          ▼                                      │
│  4. HUMAN VERIFICATION                                          │
│     Simple approval interface ("Swipe right" / Merge)           │
└─────────────────────────────────────────────────────────────────┘
```

## Key Principles

| Principle | Description |
|-----------|-------------|
| **Ubiquitous Listening** | Agent connected to Slack, Email, Meetings as passive observer |
| **Context Inference** | Parse unstructured chatter to identify actionable items |
| **Proactive Execution** | Draft PR/answer/analysis BEFORE being explicitly asked |
| **Low-Friction Review** | Humans approve via simple interfaces, not deep code review |

## Enablement Requirements

- [ ] Agent has access to team communication channels
- [ ] Agent can parse natural language intent
- [ ] Agent can create artifacts (PRs, docs, analyses)
- [ ] Simple approval workflow exists

## Common Mistakes

- **Requiring formal specs**: Train agents to interpret natural discussions
- **No proactive action**: Waiting for explicit prompts defeats the purpose
- **High-friction review**: Make approval as simple as possible

## Real-World Examples

- **Block**: "Goose" listens to meetings and proactively drafts PRs/emails
- **OpenAI**: Codex answers data queries directly in Slack

---

*Source: Alexander Embiricos (OpenAI Codex) via Lenny's Podcast*

Overview

This skill describes chatter-driven development: an agentic workflow where AI monitors unstructured team communications and proactively drafts code, PRs, answers, or analyses without waiting for formal specifications. It shifts the bottleneck from specification writing to lightweight human verification, enabling faster iteration and fewer missed requests.

How this skill works

The agent passively ingests signals from Slack, meeting transcripts, tickets, and other chatter, then applies intent extraction to label items as bugs, feature requests, or questions. It generates artifacts—patches, pull requests, documentation, or suggested replies—and surfaces them through a low-friction approval interface for human verification and merge.

When to use it

When teams communicate requirements informally across chat and meetings rather than through formal specs
When you want AI to reduce the backlog by proactively acting on observed problems or requests
When rapid iteration matters and low-friction review can replace heavy formal QA
When developers are frequently interrupted by ad-hoc asks in chat channels
When product managers want a continuous flow of draft solutions to accelerate decision-making

Best practices

Limit agent scope to specific channels and topics to reduce false positives
Require explicit human approval for code merges and production changes
Annotate generated artifacts with provenance and concise rationale
Tune intent extraction on your team's vocabulary and common request patterns
Start with low-risk artifacts (docs, tests, non-critical fixes) and expand scope gradually

Example use cases

Agent detects repeated Slack complaints about slow search and drafts a profiling PR with suggested fixes
During standups, the agent extracts feature intents and creates templated RFCs or ticket drafts for triage
Agent answers frequently asked product questions directly in chat with citations and suggested documentation edits
Automatically generates testing scaffolds for code areas mentioned in bug reports found in meetings
Agent compiles a weekly digest of inferred product priorities and proposed next steps for PM review

FAQ

How does the agent avoid acting on noise or jokes in chat?

Use channel filters, confidence thresholds, and explicit user signals (reactions or flags) before generating artifacts; start conservative and increase sensitivity after tuning.

What approvals are recommended before merging agent-generated code?

Require at least one human reviewer, automated tests, and a clear provenance note on the PR; consider staged rollout for production changes.