AI-PLC — AI-Driven Product Life Cycle with Product Discovery, Strategy and Prototyping

IMPORTANT Generative AI can make mistakes. You should consider reviewing all output and costs generated by your chosen AI model and agentic coding assistant. See AWS Responsible AI Policy.

Note: The example provided in this repository is for experimental and educational purposes only. It demonstrates concepts and techniques but is not intended for direct use in production environments.

AI-PLC is a AI-guided workflow that helps Product Managers, business leaders, and other non-technical roles define product strategy and determine what applications should be built for their business. Workflow experience is natural language conversation with agentic AI tools. It takes you from customer insights to validated prototypes — all within a single AI-assisted session. It covers pain point analysis, use case prioritization, PR/FAQ creation (Working Backwards), product strategy, go to market strategy and prototype generation.

The workflow is flexible — you can start from wherever you are. Whether you're exploring customer pain points for the first time, already have a list of use cases to evaluate and priortize, or want to jump straight into building prototypes from existing specifications. You can complete the entire journey in one session, or generate portable PROTOTYPE-*.md files and share them with other teams to build prototypes in their own workspace.

The workflows are also fully customizable to your needs — they are defined in markdown files that you can edit to adjust questions, scoring frameworks, output formats, or add domain-specific guidance for your organization.

---

Table of Contents

• Three Ways to Start
• Prerequisites
• Download the Repository
• Setup for Your Tool
• Start the Workflow
• What Happens After Discovery?

---

Three Ways to Start

AI-PLC supports three entry points — from broad exploration to focused execution. Choose based on where you are in your product thinking:

Entry Point 1: Start from Customer Pain Points

You have: Customer feedback, reviews, research, or a general problem area to explore.

What happens: The AI guides you through gathering pain points (from URLs, free-form text, or structured questions), creates a PR/FAQ using the Working Backwards method, analyzes potential solutions, and generates prototype specifications.

Best for: Teams starting fresh, exploring a new problem space, or wanting to validate customer needs before building.

Entry Point 2: Start from Use Cases

You have: Multiple use case ideas (3, 5, 10, or 20+) that need evaluation and prioritization.

What happens: The AI helps you document all use cases, scores them using prioritization frameworks (separate frameworks for agentic vs. application use cases), selects the top 3, and generates PROTOTYPE-*.md specifications for each.

Best for: Teams with many ideas that need a structured way to pick the best ones.

Entry Point 3: Build from Existing Prototype Specs

You have: Prototype specification md files that wer already generated from entry point 1 or entry point 2. This separate entry point allows you to run one session collectively to agree on what prototype should be built and create specifications accordingly and then , either use same session or hand over the specifications to other team who can start with these specifications in this third entry point to create prototype.

What happens: Skips all discovery and goes straight to building prototypes from the specifications.

Best for: Teams who received PROTOTYPE-*.md files from another group, or picking up where a previous session left off.

---

Key Features

Feature	Description
PM-Focused	No coding required — focuses on product vision and decisions
Three Entry Points	Start from pain points, use cases, or existing prototype specs
Scalable	Supports any number of use cases (3, 5, 10, 20+)
Team-Friendly	PROTOTYPE-*.md files are portable and shareable across teams
Auditable	Complete trail of all decisions in audit.md
Handoff-Ready	Discovery Document ready for developer teams to use as context for creating prod application

Example Scenarios

Customer-Driven Discovery

1. PM collects customer reviews from Yelp, Trustpilot, or internal research or have free form text curated already from research
2. Starts from Entry Point 1 (pain points) — provides the URL
3. AI extracts pain points, creates PR/FAQ, identifies solutions
4. PM reviews and approves, then builds a prototype in the same session

Use Case Selection

1. Product team has 10 potential AI use case ideas
2. Starts from Entry Point 2 (use cases)
3. AI scores and ranks all 10, recommends top 3
4. PM confirms selection, generates PROTOTYPE-*.md files
5. Optionally builds prototypes or hands off files to engineering

Distributed Team Collaboration

1. A core team uses Entry Point 1 or 2 together to analyze pain points and prioritize use cases as a group
2. The workflow generates PROTOTYPE-*.md files for the top use cases
3. PROTOTYPE-*.md files are distributed to separate teams
4. Each team opens their own workspace with Entry Point 3 and builds their assigned prototype independently
5. Teams reconvene to present and compare results

Key concept: The workspace supports collaborative product thinking (pain point analysis, use case selection) as a team activity. Once PROTOTYPE-*.md files are generated, they become portable artifacts that can be distributed to multiple teams for parallel prototype development in separate workspaces.

---

Prerequisites

Admin/Installation Permissions

You will need administrator permissions on your computer to:

• Install Git, Claude Code, or Kiro
• Install packages during prototype building (Python, Node.js libraries are installed automatically)

If you don't have admin access, ask your IT team to install the prerequisites for you.

Git (required to download this repo)

Check if you already have it:

git --version

If you see a version number, you're good — skip to the next section.

Install Git if needed:

OS	Command
macOS	Type git --version in Terminal — macOS will prompt you to install it
Windows	Open Command Prompt as Administrator, run: winget install Git.Git
Linux	sudo apt update && sudo apt install git

Claude Code or Kiro (pick one)

Tool	What It Is	Get It Here
Claude Code	Anthropic's AI coding assistant (runs in your terminal)	Install Claude Code
Kiro	AWS's AI-powered IDE	Install Kiro

---

Download the Repository

Step 1: Open your Terminal application.

• macOS: Open Finder → Applications → Utilities → Terminal
• Windows: Press Windows key, type "Command Prompt", press Enter
• Linux: Open your terminal emulator

Step 2: Check what folder you are currently in by running this command:

macOS/Linux:

pwd

Windows:

cd

This shows you where files will be downloaded to. If you want to download somewhere specific (like your Desktop), navigate there first:

cd ~/Desktop

Step 3: Download the repository:

git clone https://github.com/aws-samples/sample-ai-plc.git 

This creates a folder called sample-ai-plc containing all the workflow files.

---

What's Inside the Download

sample-ai-plc/
├── aiplc-rules/
│   ├── aws-aiplc-rules/
│   │   └── core-workflow.md              ← Main workflow instructions
│   └── aws-aiplc-rule-details/           ← Supporting rules (loaded as needed)
│       ├── common/
│       ├── discovery/
│       └── inception/
└── README.md                              ← This file

---

Setup for Your Tool

• Claude Code
• Kiro

---

Claude Code

Claude Code uses a CLAUDE.md file in your project root as its instructions.

Step 1: Create a new project folder. Open Terminal and run:

mkdir my-discovery-project
cd my-discovery-project

You can replace my-discovery-project with any name you prefer (e.g., my-ai-product, etc.)

Step 2: Copy the workflow files into your project. Replace ~/Desktop/sample-ai-plc with the actual path where you downloaded the repository:

macOS/Linux:

cp ~/Desktop/sample-ai-plc/aiplc-rules/aws-aiplc-rules/core-workflow.md ./CLAUDE.md
cp -R ~/Desktop/sample-ai-plc/aiplc-rules/aws-aiplc-rule-details ./aws-aiplc-rule-details

Windows (PowerShell):

Copy-Item "$env:USERPROFILE\Desktop\sample-ai-plc\aiplc-rules\aws-aiplc-rules\core-workflow.md" ".\CLAUDE.md"
Copy-Item -Recurse "$env:USERPROFILE\Desktop\sample-ai-plc\aiplc-rules\aws-aiplc-rule-details" ".\aws-aiplc-rule-details"

Windows (CMD):

copy "%USERPROFILE%\Desktop\sample-ai-plc\aiplc-rules\aws-aiplc-rules\core-workflow.md" ".\CLAUDE.md"
xcopy "%USERPROFILE%\Desktop\sample-ai-plc\aiplc-rules\aws-aiplc-rule-details" ".\aws-aiplc-rule-details\" /E /I

Note: If you downloaded the repository to a different location (not Desktop), adjust the path accordingly.

Your project should look like:

my-discovery-project/
├── CLAUDE.md                         ← Workflow instructions
├── aws-aiplc-rule-details/           ← Supporting rules
│   ├── common/
│   ├── discovery/
│   └── inception/
└── aiplc-docs/                       ← (created automatically during workflow)

Step 3: Start Claude Code in your project folder:

claude

Verify it works: Ask Claude "What instructions are currently active?" — it should describe the AI-PLC Discovery workflow.

---

Kiro

Kiro uses steering files in a .kiro/ directory within your project workspace.

Step 1: Create a new project folder. Open Terminal and run:

mkdir my-discovery-project
cd my-discovery-project

You can replace my-discovery-project with any name you prefer (e.g., my-ai-product, etc.)

Step 2: Create the required directories and copy files. Replace ~/Desktop/sample-ai-plc with the actual path where you downloaded the repository:

macOS/Linux:

mkdir -p .kiro/steering
cp -R ~/Desktop/sample-ai-plc/aiplc-rules/aws-aiplc-rules .kiro/steering/
cp -R ~/Desktop/sample-ai-plc/aiplc-rules/aws-aiplc-rule-details .kiro/

Windows (PowerShell):

New-Item -ItemType Directory -Force -Path ".kiro\steering"
Copy-Item -Recurse "$env:USERPROFILE\Desktop\sample-ai-plc\aiplc-rules\aws-aiplc-rules" ".kiro\steering\"
Copy-Item -Recurse "$env:USERPROFILE\Desktop\sample-ai-plc\aiplc-rules\aws-aiplc-rule-details" ".kiro\"

Windows (CMD):

mkdir .kiro\steering
xcopy "%USERPROFILE%\Desktop\sample-ai-plc\aiplc-rules\aws-aiplc-rules" ".kiro\steering\aws-aiplc-rules\" /E /I
xcopy "%USERPROFILE%\Desktop\sample-ai-plc\aiplc-rules\aws-aiplc-rule-details" ".kiro\aws-aiplc-rule-details\" /E /I

Note: If you downloaded the repository to a different location (not Desktop), adjust the path accordingly.

Your project should look like:

my-discovery-project/
├── .kiro/
│   ├── steering/
│   │   └── aws-aiplc-rules/
│   │       └── core-workflow.md      ← Workflow instructions
│   └── aws-aiplc-rule-details/       ← Supporting rules
│       ├── common/
│       ├── discovery/
│       └── inception/
└── aiplc-docs/                       ← (created automatically during workflow)

Step 3: Open Kiro IDE:

kiro .

Or open Kiro IDE and use File → Open Workspace to select your project folder.

Step 4: Enable Vibe Mode — this lets the AI guide you through the workflow.

Note: Kiro may sometimes nudge you to switch to Spec mode. Select No to stay in Vibe mode for the AI-PLC workflow.

Verify it works: Open the steering files panel and confirm you see core-workflow listed under Workspace.

---

Start the Workflow

Once setup is complete, start a conversation with your AI tool using one of these prompts based on your starting point:

Starting from Customer Pain Points (Entry Point 1)

Use this when you have customer feedback, reviews, or a problem area to explore:

"I want to start AI-PLC Discovery from customer pain points"

or

"Help me create a PR/FAQ from customer feedback"

The AI will gather pain points (you can provide a URL, describe them in your own words, or answer structured questions), then guide you through PR/FAQ creation, solution analysis, and prototype specification.

Starting from Use Cases (Entry Point 2)

Use this when you have multiple use case ideas to evaluate:

"I have use cases that need prioritization using AI-PLC"

or

"Start AI-PLC Discovery workflow for use case prioritization"

The AI will help you document all use cases, score and rank them, select the top 3, and generate PROTOTYPE-*.md files.

Building from Existing Prototype Specs (Entry Point 3)

Use this when you already have PROTOTYPE-*.md files in your workspace:

"Start the AI-PLC workflow to build my prototypes"

or

"I have PROTOTYPE-*.md files ready, let's build them"

The AI will read the specifications and build prototypes directly.

---

How the AI Interacts with You

The AI will:

1. Detect your workspace and determine the right entry point
2. Ask you questions in .md files (you fill in [Answer]: tags)
3. Guide you through each stage with approval gates
4. Produce the Discovery Document and prototype specifications

Tip: If the AI starts asking questions directly in chat instead of creating files, say: "Please create a question file (.md) with [Answer]: tags instead of asking in chat."

---

What Happens After Discovery?

The Discovery Document

The main output is aiplc-docs/discovery/discovery-document.md — a single comprehensive file containing everything needed for product development:

Discovery Document Sections:
├── Pain Point Analysis          — Customer problems, severity, market sizing
├── PR/FAQ                       — Working Backwards press release and FAQs
├── Solution Analysis            — Identified solutions from the PR/FAQ
├── Use Case Prioritization      — Scored and ranked use cases
├── Prototype Specifications     — PROTOTYPE-*.md files for selected solutions
├── Product Strategy             — Positioning, differentiation, business model
└── Go-to-Market Plan            — Marketing, sales approach, launch planning

Using the Discovery Document for Software Development

The Discovery Document is a .md file designed to be dropped into the context of AI-powered software development tools. You can:

• Add it to AI-DLC (AI-Driven Development Life Cycle) as input for the Inception phase — developers use it for requirements analysis, workflow planning, and application design
• Add it to any AI coding tool (Claude Code, Kiro, Cursor, GitHub Copilot, etc.) as project context for building the product
• Share it with development teams as a traditional product brief — it's readable markdown that works with or without AI tools

Supporting Artifacts

In addition to the main Discovery Document, the workflow generates:

• aiplc-docs/discovery/prototypes/*/PROTOTYPE-*.md — Portable prototype specifications
• aiplc-docs/discovery/envision/pain-point-analysis.md — Detailed pain point breakdown
• aiplc-docs/discovery/prioritization/scoring.md — Use case scoring rationale
• aiplc-docs/audit.md — Complete audit trail of all decisions and inputs

---

Security Considerations

This workflow is designed for local prototyping only — not production use. Be aware of the following:

• Prototypes have no authentication. Generated apps run on localhost with no auth layer. Never expose them on a public network.

• PROTOTYPE-*.md files are trusted as specifications. Only use files you or your team created. Do not import PROTOTYPE-*.md files from untrusted sources — they drive code generation directly.

• Audit logs capture your full input. audit.md and aiplc-state.md contain verbatim session data. Do not commit these to shared repositories if you've entered sensitive business information.

• Credentials are environment-variable based. Never paste API keys into chat. If you accidentally do, revoke and regenerate them. The workflow will attempt to redact recognized patterns but cannot catch all credential formats.

• URL fetching has basic SSRF protections but is not hardened against advanced bypass techniques (DNS rebinding, IPv6, redirects). Only provide URLs you trust.

• Session state (aiplc-state.md) is not integrity-checked. In shared workshop environments, be aware that manual edits to this file can skip workflow gates.

• For AWS credentials: prefer temporary credentials (SSO/assumed roles) over long-lived access keys. If using temporary credentials, also set AWS_SESSION_TOKEN.

---

License

This library is licensed under the MIT-0 License. See the LICENSE file.