DEV Community: PHUC NGUYEN

Kioku: Why I built a Knowledge Graph memory engine for my AI agents

PHUC NGUYEN — Mon, 02 Mar 2026 16:06:45 +0000

Hey builders and open-source community!

Today I want to share a side-project I've been building to solve a very personal pain point that I believe many of you also face: How do you give AI a real "long-term memory" that understands emotions and causal relationships?

That's why Kioku was born. Kioku (記憶) means "memory" in Japanese — 記 (ki) to record, 憶 (oku) to remember. It's an ultra-lightweight Personal Memory Engine, runs entirely local, designed specifically for AI Agents.

The origin: A journal-writer's frustration

I'm someone who journals daily. I like to self-reflect and look back at past events. In the age of AI, I've tried many tools and chatbots for this, but the results were always disappointing.

The core problem: No tool truly solves the challenge of storing, analyzing emotions, and understanding causal relationships between actions.

Popular agents today (even the big names) have "long-term memory" features, but they essentially just store flat text or vectors stuffed into a context window. When you ask "Why was I stressed about project X last month?", the system gets confused because it can't connect event A (argument with boss) leading to emotion B (stress) and decision C (switching projects). It lacks connection.

The solution: An open memory engine for any agent

As a daily user of AI tools, especially coding agents (Claude Code, Windsurf, Cursor), I realized: Instead of building a new bot from scratch, why not create an independent memory organ that plugs into our favorite agents?

The goal was to make it compatible with as many agents as possible. That's why for the lite version (kioku-lite), I chose an architecture based on CLI and SKILLS files (specifically the AGENTS.md & SKILL.md format popular among CLI agents today). With just a few commands, any agent can learn to read/write memories.

Architecture overview: Write, search, and comparison

Kioku Lite uses a Tri-hybrid search mechanism running 100% on SQLite:

BM25 (FTS5): Exact keyword search.
Vector (sqlite-vec + FastEmbed ONNX): Semantic search (runs local, no API needed).
Knowledge Graph (GraphStore): Entity graph with causal relationships.

Here's the system overview:

The protocol has 2 main phases, orchestrated by the agent:

1. Write phase

When a new event occurs: The agent saves text (save) then autonomously extracts entities/relationships and indexes them into the Graph (kg-index). Everything runs locally, no hidden LLM calls.

2. Search phase

When context is needed: The agent calls search. Results go through 3 separate pipelines and are fused via RRF (Reciprocal Rank Fusion):

Memory model comparison

How does Kioku Lite compare to familiar systems?

System	Memory Model	Persistence	Search	Knowledge Graph
Claude Code	Flat markdown files	Session-scoped + `CLAUDE.md` / `MEMORY.md`	None (context window only)	No
OpenClaw	SQLite chunks + embeddings	Per-agent SQLite database	Semantic (embedding-based)	No
Kioku Lite	SQLite + Markdown + KG	Per-profile isolated stores	Tri-hybrid (BM25 + vector + KG)	Yes (Agent-driven)

(Deep dive: System Architecture | Write Pipeline | Search Architecture | Memory Comparison)

Knowledge Graph (KG): The key to flexibility

Another strength of Kioku Lite is the Open Schema for its Knowledge Graph. Entity types (entity_type) and relationship types (rel_type) are flexible strings, not locked into fixed enums.

Kioku-lite ships with 2 built-in personas:

Companion: Agent extracts EMOTION, LIFE_EVENT nodes linked by TRIGGERED_BY. Ideal for journaling and emotion tracking.
Mentor: Agent extracts DECISION, LESSON nodes linked by LED_TO. Ideal for self-reflection and learning from experience.

You can also ask your agent to configure entirely new personas for any domain you need, such as HR management, product management, or any other field where you want your agent to remember things in a specific way.

(Schema details: KG Open Schema)

Setup in one copy-paste

Two setup guides are ready for the 2 agent types I use daily:

Just copy the relevant guide and paste it to your agent. It will auto-run setup, configure identity, and connect to the memory engine on your machine.

Full details at Kioku Lite Homepage.

Kioku Lite vs Kioku Full

kioku-lite ships first, targeting Personal Users. Setup is fast via pipx, no Docker, no API keys, no external databases like ChromaDB/FalkorDB. Runs silently in the background on your personal machine.

Meanwhile, kioku-full with dedicated graph and vector databases, multi-tenant Enterprise support, is still under active development.

Closing

If you're a builder, an open-source enthusiast, and especially if you're still looking for a "long-term memory" solution that helps AI understand emotions and causality like a real companion, give Kioku Lite a try.

Homepage: phuc-nt.github.io/kioku-lite-landing
GitHub: github.com/phuc-nt/kioku-agent-kit-lite

Your feedback and support at this stage means the world. Try it out, share it with anyone who needs it, or simply drop a Star on the repo!

Thanks for reading! Happy coding and looking forward to your feedback!

Context Engineering: From Vibe Coder to AI Orchestrator

PHUC NGUYEN — Mon, 08 Sep 2025 16:09:22 +0000

Context Engineering

In my previous post about "AI Coding: From Vibe Coding to Professional", I mentioned Context Management as Best Practice #6 in the journey to become an AI Orchestrator. But that was just the overview – a high-level view of the importance of context management.

Today's post will dive deep into this topic. I'll share a specific, immediately applicable framework so you can truly master Context Engineering – the art of building a "collective brain" for AI.

Context Engineering isn't just about providing information to AI. It's a systematic approach to building an environment where AI always receives the right information, at the right time, to complete tasks most effectively. Imagine: instead of having to "brief" AI from scratch each time, you create a system where AI automatically knows what to do, following which process, and to what standards.

This is precisely the difference between "going with the flow with AI" and "orchestrating AI" – between Vibe Coder and AI Orchestrator.

This framework isn't a silver bullet for every type of project, but it's been tested by me on several "weekend projects", so I can confidently say it will help with small projects (under 20MD if done by humans), and test environments simple enough for Agents to automate with test suites.

So, if you share similar interests with me, let's continue.

Vibe Coding and Context Engineering

One of my weekend projects was building an MCP server for Confluence Data Center with 11 tools. A project small enough to test AI coding capabilities.

When still "Vibe Coding"

I jumped straight in with the "wing it" style. Opened Claude and started:

Me: "Hey Claude, I need to build an MCP server for Confluence DC, with 11 tools."

Claude: "Great! Could you tell me specifically what those 11 tools are?"

Me: "Ah... there's createPage, getPage... umm... let me remember..."

The price paid was steep: 5 days passed, only 4/11 tools completed, codebase full of "technical debt", and every day I spent hours just "briefing" AI. Stress skyrocketed, confidence hit rock bottom.

Slowing down with "Context Engineering"

Disappointed but not giving up, I decided to try again. This time, instead of rushing to code, I spent the first 2 hours building a "brain" for AI through a documentation system:

docs/
├── 00_context/                  # AI's Long-term Memory
│   ├── requirements.md          # Business goals, success criteria
│   ├── implementation-guide.md  # Technical architecture, patterns
│   └── reference.md             # Additional references
├── 01_plan/                     # Project Management  
│   └── project-roadmap.md       # Timeline, current status, sprints
└── 02_implement/                # Sprint Execution
    ├── sprint-1.md              # Detailed task breakdown
    ├── sprint-2.md              # Daily progress tracking
    └── sprint-3.md              # Acceptance criteria

And here's how my new session started:

Me: "Hey, we're starting the MCP server project. First, please read all documentation in docs/ to understand the context."

Claude: "I've read and understand clearly. According to project-roadmap.md, we'll start with Sprint 1. Based on implementation-guide.md, I'll use the single API client model... Shall we begin?"

That's magic. In just 3 days, I not only completed 11/11 tools with production-ready quality but also published it as an npm package.

That magic is called process – something Vibe Coders often forget. Next is the complete content of the framework you can take and try immediately.

3 Steps to Context Engineering

Great that you haven't given up yet.

How to start now? It's simpler than you think. Here are 3 steps for you:

Step 1: Build AI's Long-term Memory

Don't do everything yourself! Let AI build context for itself.

Create requirements.md: Use a Reasoning AI to play Product Manager. Brainstorm with it to create detailed requirements. You can refer to the process I shared in the post Optimizing Requirement Writing with AI.
Complete remaining documents: Once you have proper requirements.md, hand them to an Internet Search AI. It will quickly suggest architecture, coding patterns and create the remaining technical documents for you.

Step 2: Set up AI's Rules

This is when you give AI a "behavioral rulebook". Create a base rules file in your project (depending on the Agent you use, the file will be named CLAUDE.md or clinerules.md).

Inside this file, you'll define everything, from Startup Workflow (what AI must do when starting a session), Task Lifecycle (lifecycle of a task from start to completion), Quality Gates (conditions to be considered "done"), to Documentation Rules. This is the "handbook" that helps AI behave like a disciplined engineer instead of a confused intern.

Visualize this rules set as the following process:

And here's the detailed content for you to copy paste, to put in CLAUDE.md or clinerules.md, depending on your Agent:

### Startup Workflow (Each Session)

1. Check the project setup.
2. **Read `docs/01_plan/project-roadmap.md`** - To understand the project status and current focus.
3. **Reference context documents** - `requirements.md`, `implementation-guide.md` as needed.

### Task Management Process

Task Lifecycle:
  1. Identify task: From the current sprint or user request.
  2. Focus mode: Work on one task at a time, do not jump around.
  3. Implement feature: Code implementation with proper error handling.
  4. Test Suite Update: MANDATORY - Update the test suite for every new feature.
  5. Quality validation: All tests must PASS before marking a task as complete.
  6. Update progress: Update the sprint document only when ALL TESTS PASS.
  7. Commit clean: Use a clear commit message following conventions.
  8. Update status: Update the sprint document and `project_roadmap.md`.

Quality Gates:
  - Code compiles: The build must succeed.
  - Test Suite: All automated tests (connection + functional) must PASS.
  - No regressions: Existing functionality must not be broken.
  - No token leaks: Do not commit sensitive data.
  - Documentation: Update docs with test results.

Test Requirements:
  - Every new feature requires corresponding tests.
  - Tests must PASS before a sprint task can be completed.
  - The test suite must be maintained and updated consistently.

### Role of Document Groups

**`00_context/` - Technical Foundation (DO NOT EDIT WITHOUT EXPLICIT APPROVAL)**:
- `requirements.md`: Business requirements, project scope, success criteria.
- `implementation-guide.md`: Technical architecture, code patterns, API client structure.
- `confluence-tools-reference.md`: Complete tool-to-API endpoint mapping reference.

**`01_plan/` - Project Management**:
- `project-roadmap.md`: Project timeline, current status, sprint progress, next actions.

**`02_implement/` - Sprint Execution (UPDATED DAILY)**:
- `sprint-X-*.md`: Detailed task breakdown, acceptance criteria, daily progress tracking.

### Documentation Rules

Update Rules:
  project_roadmap.md: Update for major progress, phase completion, current status.
  sprint_*.md: Update for daily progress, task completion.
  00_context/: Never update without explicit approval (requirements, architecture, API specs).

Maintenance Principles:
  - AVOID DUPLICATION: Link instead of repeating information.
  - KEEP CONCISE: Overview docs stay short, details go in specific docs.
  - SINGLE SOURCE OF TRUTH: Each piece of information lives in one place.
  - CROSS-REFERENCE: Use links to connect related information.
  - STATUS FIRST: Always show the current status clearly.

Writing Style:
  - Concise and actionable.
  - Use status indicators: Not Started, In Progress, Completed, Blocked.
  - Include time estimates and actual time spent.
  - Link related documents instead of duplicating content.

  Document Flow: `project_roadmap.md` → `sprint_*.md` → specific details.
  Never put detailed task lists in overview documents.

Step 3: There is no Step 3

That's it, just ask the Agent:

"You know what to do."

And then, sit down, sip your coffee and watch the magic. AI will automatically read the roadmap, identify the next task, and start implementing according to the process you've established.

Conclusion

And that's it. 3 simple steps (actually just 2), but the effectiveness is significant.

This framework isn't something divine that will solve all problems. It's only particularly effective for small projects with clear test suites, and when you have time to invest in initial context setup.

But when it works, it really works.

With various "weekend projects", the results I get are always consistent: AI no longer "gets lost", code quality is stable, and most importantly, I don't stress about losing control.

This is precisely the difference between Vibe Coder and AI Orchestrator.

Vibe Coder prompts and hopes. AI Orchestrator creates an ecosystem for AI to operate effectively.

If you've followed the journey from the previous post - from Vibe Coding to disciplined process - then Context Engineering is the final piece. It turns theoretical Best Practices into a concrete, repeatable workflow.

Now, you have enough tools to not just "go with the flow with AI" but truly "orchestrate AI".

Good luck with your next weekend project!

From Vibe Coding to Professional AI-Powered Development: A Practical Handbook

PHUC NGUYEN — Wed, 27 Aug 2025 16:55:46 +0000

The promises of AI coding are alluring: building an entire application in just one afternoon. This is the world of "Vibe Coding" – fast, but also the shortest path to technical debt. So how do we harness this amazing power without creating a mess we'll regret later?

This article is my answer. Not to make you abandon AI, but to help you master it. We'll go beyond simple prompts to build a professional process where AI plays the role of a disciplined teammate, not an unpredictable intern. My goal is to give you a practical handbook to turn AI into a true collaborator, helping you build better, more robust, and naturally, faster software.

What is Vibe Coding?

Imagine you're a developer named Tom, who just received a request to build a project management app. You're excited, fire up Cursor (or whatever AI you prefer), type a prompt like: "Write me a project management app with React". And boom, in just 1 hour, you have a working prototype! You feel like Tony Stark, just say one sentence and JARVIS does everything. That's "Vibe Coding" – programming by inspiration, quick and easy, relying on AI without carefully checking the code it produces.

But wait, not everything stays rosy. According to Simon Willison's definition, "Vibe Coding" is when you use large language models (LLMs) to build software without really carefully considering what they create. The result? Tom's codebase becomes a mess, without structure, full of temporary solutions. When the client requests additional features, Tom starts sweating because he doesn't know where to start fixing.

Don't get me wrong, "Vibe Coding" isn't bad. It's fast, it helps you create prototypes in (tens of) minutes, saving hours compared to traditional methods. As Steve Yegge pointed out in his article "Revenge of the Junior Developer", vibe coding can be "5x more effective than traditional programming" and is increasingly becoming an unavoidable trend as tools like coding agents emerge. However, the flip side of this coin is not light. According to CSET's report (November 2024), nearly half of AI-generated code contains errors, even security vulnerabilities that can be exploited. Speed is there, but without foundational knowledge to control it, you'll turn yourself into a security time bomb. Addy Osmani also emphasizes in his blog that "speed means nothing if the wheels fall off halfway", and vibe coding is not an excuse for low-quality work.

So how do we keep the speed without shooting ourselves in the foot? The answer lies in professional AI-powered programming. Let's explore!

Professional AI-Powered Programming: Slow but Sure

Now meet Sarah, another developer in our story. Sarah isn't rushed like Tom. Instead, Sarah takes time to plan, design architecture, break down sprints like a real Scrum Master. The result? After 2 weeks, Sarah has a solid product, easily scalable and maintainable in the long run. Sure it's slower at first, but anything worthwhile usually takes time, right?

So how does professional AI-powered programming differ from "Vibe Coding"? It's not about abandoning AI, but using AI in a controlled manner. I summarize it into 2 foundational mindsets you need to remember:

Trust the Process: AI is most powerful when integrated into a clear process system. Don't let AI run too free, give it a "map" to follow.
AI as Teammate: AI isn't a replacement for you, but a colleague. Coordinate, evaluate and adjust its output, just like how you work with another programmer on the team.

This perspective is reinforced by Mike Krieger, CPO of Anthropic, who emphasizes that in the future, programmers will shift from writing code to the role of "AI Orchestrators" – coordinating AI, designing systems and ensuring quality. At Anthropic, embedding Product Managers with AI researchers has increased efficiency by 10x, showing the importance of coordinating humans and AI as teammates (Mike Krieger Interview).

To better illustrate how AI can become a teammate, look at the diagram below:

This diagram shows you (Product Owner) playing the guiding role, while various AIs take on specific tasks like requirements, research and code writing. Most importantly, there's a feedback loop for you and AI to evaluate and adjust together. This is the spirit of "AI as Teammate" – collaborating like members of a real team.

8 Best Practices

Now that we understand the mindset, let's go into detail with 8 best practices to elevate from "Vibe Coding" to professional AI-powered programming. I divide them into 4 familiar stages in software development: Preparation, Planning, Development, and Troubleshooting.

Preparation

The preparation phase is like laying the foundation for a house. If the foundation isn't solid, the entire structure will collapse. Here are the first 2 best practices:

Best Practice 1: Coordinate Multiple AI Tools

Don't rely on just one AI. Create a pipeline where each AI takes on a separate role. For example:

Reasoning AI: Specializes in writing requirements documents, design, and implementation instructions.
Internet Search AI: Searches for the latest information about frameworks or community experiences.
Coding AI Agent: Focuses on writing code.

The output of one AI becomes the input for another, ensuring consistency and quality. Think about it, you're building a super-powered AI team, not just having one superhero! This perspective is supported by Steve Yegge in his article, when he predicts the emergence of "agent clusters" and "agent fleets" – where programmers manage multiple agents in parallel to handle different tasks, from bug fixing to developing new features.

Best Practice 2: Prepare Detailed Requirements

Requirements are the roadmap for AI. If the map is vague, AI will lead you into a forest of errors. Turn AI into a brainstorming assistant, chat with it like a colleague to discover new perspectives and detect gaps in initial requirements. You can refer to details of how I do this in my blog: Optimizing Requirement Writing with AI. Addy Osmani also encourages keeping humans in the design leadership position, using AI for execution rather than deciding basic architecture, ensuring requirements are clearly defined from the start (Addy Osmani Substack).

The mindset at this stage: "Preparation is the foundation of success". Don't rush to code, take time to build the team and clarify what you want to create.

Planning

The planning phase is when you concretize what needs to be done. In Scrum, this is Sprint Planning. Here are the next 2 best practices.

Best Practice 3: Task Breakdown for AI

AI works best with small, independent tasks. Break down according to "AI-friendly tasks" rules:

Each task no more than 100-200 lines of code.
Clear input/output.
Little dependency on context from other tasks.
Specific test cases to verify.

Save the task list and implementation plan in the folder containing source code, so the Coding Agent can easily access context. Nobody wants to work in the dark, including AI! Steve Yegge emphasizes that breaking down tasks is extremely important when working with coding agents, because if you give agents tasks that are too large, they will "bang their heads against the wall" without achieving results (Sourcegraph Blog).

Best Practice 4: Setup Implementation Rules

Create a "company handbook" for AI, called Implementation Rules. It defines coding standards, preferred patterns and workflow. When AI has clear rules, it won't have to guess your intentions, but focus 100% on business logic. Addy Osmani also agrees with this idea, recommending teams establish coding standards and ensure AI output is edited to comply before integrating into the codebase (Addy Osmani Substack).

The mindset here is: "Structure enables creativity". Good structure doesn't constrain, but liberates creativity for both you and AI.

Development

Development is when you and AI work together to turn ideas into reality. Here are 2 important best practices.

Best Practice 5: Edit-Test Loops

Edit-Test Loops are the most effective way to work with AI. Each cycle should only last 15-30 minutes, enough for AI to focus and give quick feedback. The process is as follows:

Identify a small increment (15-30 minutes).
Write failing test case for this increment.
Ask AI to implement code to make test pass.
AI automatically runs test.
If fail, AI analyzes and fixes code. If pass, review and commit.

Addy Osmani also emphasizes the importance of thorough testing, advising that all AI-generated code needs to be tested both manually and automatically to detect errors, especially unexpected cases that AI often overlooks (Addy Osmani Substack). Additionally, Mike Krieger from Anthropic shares that at their company, AI not only writes code but is also used to review other AI's code, with humans only performing acceptance testing, significantly speeding up the review process (Mike Krieger Interview).

To illustrate more clearly, look at the diagram about the Development phase below:

This diagram shows how you and AI work through short loops, with clear checking and progress saving steps.

The mindset here is: "Small iterations, continuous feedback". Don't let AI take on too much, guide step by step.

Best Practice 6: Context Management

Context is AI's "memory", but if context is too long, AI will get "confused" and produce inconsistent results. Manage context effectively with the following methods:

Use @ references to add specific files.
Start new chat if context exceeds 50-100 messages.
Resync codebase regularly.
Use git commits as checkpoints.
Create summary after each session.

The diagram below illustrates how to manage context:

The Context Repository stores all important information, and each AI working session reads/writes to it to ensure consistency.

Troubleshooting

AI isn't always perfect. Sometimes it will struggle and not be able to solve problems. Don't panic, use these 2 best practices:

Best Practice 7: Problem Report System

When AI encounters difficulties, ask it to create a Problem Report, describing in detail the current state, error messages and solutions tried. Then, give this report to another Search AI for a fresh perspective, like asking for expert opinion outside the team. Addy Osmani also supports using AI iteratively, encouraging programmers to ask AI to improve output if initial results don't meet requirements, or even abandon AI to write code themselves if needed (Addy Osmani Substack).

Best Practice 8: Context Reset Strategy

When everything is too messy, be bold and "reset". Context reset is the "emergency brake" when AI goes in the wrong direction. When to reset? When conversation exceeds 100 messages, AI starts hallucinating or repeating infinitely. An effective reset method is to summarize progress into a problem report, then start a fresh conversation with clean context.

The diagram below illustrates the troubleshooting process:

The mindset here? "Systematic beats random". Don't try to fix errors randomly, be systematic: document, analyze, consult, and apply a structured approach.

"Trust The Process"

To help you visualize the entire AI workflow more clearly, look at the "Trust the Process" diagram below. It covers all 4 stages from Preparation to Troubleshooting:

This diagram shows that working with AI is not AI-centric, but process-centric. The process establishes a clear framework, while AI is just the implementation tool within it. Context is stored and reused throughout, ensuring AI always has enough information to work effectively. Mike Krieger from Anthropic also emphasizes that when AI can write code quickly (90-95% of code at Anthropic is already AI-generated), new bottlenecks emerge in feature decision-making and merge queues, so processes need to be redesigned to adapt (Mike Krieger Interview).

Conclusion

The software development world is entering a new era, where AI is no longer a passive tool, but becomes a companion in every line of code. But let's pause and think about how we've worked together over the years.

When building a development team, you never just hire a bunch of people then throw them into a room and say "Do something cool!". Instead, you place each person in the right position: Frontend Developer for UI, Backend Developer for API, DevOps for infrastructure. You clearly define input and output for each role – Designer gives mockups to Frontend, Frontend provides API specs to Backend. And most importantly, you review each member's output from the beginning through code reviews, daily standups, and sprint demos. Nobody gets to "freely create" without feedback!

Working with AI is exactly the same. You can't completely delegate to one AI and expect it to solve everything automatically. Instead, you need to guide the approach carefully like onboarding a new junior developer, adjust each AI's output like reviewing a colleague's code. Each AI in your "team" needs a clear role, specifically defined input/output, and output needs to be thoroughly checked before moving to the next step. When you apply this approach correctly, AI can produce output faster and better than humans in areas where it excels. And when each "AI member" on the team operates effectively, the overall project output will be significantly improved.

To collaborate effectively, remember 2 mindsets: Trust the Process and AI as Teammate. Trust the process, invest time in planning, testing and continuous improvement. Treat AI like a real teammate – share goals, provide feedback and solve problems together.

Success with AI doesn't lie in being the best coder, but in team management and process skills. Try applying the 8 best practices above, and you'll find yourself not only coding faster, but also viewing problems more deeply, solving challenges more effectively. As Steve Yegge said, "AI doesn't need to prove it's better than you, but you need to be better thanks to AI". He also predicts that programmers' roles will shift to managing "agent fleets", and those who don't adapt will fall behind, especially senior devs compared to junior devs – those who are quickly embracing AI (Sourcegraph Blog). Are you ready to become an AI Orchestrator, coordinating the entire AI ecosystem?

Start today, and remember, the journey with AI is just like working with humans – it needs planning, coordination, and patience. Happy coding, and don't forget to leave comments if you have questions or experiences to share!

Optimizing Requirement Writing with AI: From Vague to Detailed

PHUC NGUYEN — Thu, 14 Aug 2025 12:10:43 +0000

As a Product Owner (PO) or Business Analyst (BA), you've likely encountered situations where a client, stakeholder (or even yourself) presents a very general request, such as:

"I want to create a chatbot agent."

Typically, you would need to organize multiple meetings, ask a series of questions, and spend a lot of time clarifying the request before you can start writing the Software Requirements Specification (SRS) document. But now, with AI's help, you can streamline this process quickly and effectively.

AI Prompt - "The Software Requirements Elicitation and Specification Expert"

One of the most effective ways to leverage the power of AI is to use a specialized prompt designed specifically for software requirements elicitation and specification. This prompt directs the AI to act as a business analyst with over 15 years of experience, proficient in international standards like IEEE 830, IREB, ISO/IEC/IEEE 29148:2018, and Agile methodologies (User Stories).

This prompt includes key sections:

Role and Mission Introduction: Establishes the AI's responsibilities and scope of work.
Structured Questioning Skills: Guides the AI on how to ask questions in a clear, step-by-step manner.
Systematic Elicitation Process: A 5-step process from initial information assessment to creating a complete requirements document.
Requirements Quality Standards: Ensures requirements are clear, specific, well-prioritized, and non-conflicting.

The full prompt is available at the end of this article.

From a Vague Idea to a Complete SRS Document with AI

Let's look at a practical example to better understand this prompt's effectiveness. Suppose you start with a very general request:

"I want to create a chatbot agent."

Without AI's help, you would have to come up with numerous questions yourself to clarify the objective, target users, desired features, and so on. But with this specialized prompt, the AI will proactively ask structured questions to elicit information from you:

Exploratory Questions:
- "Can you describe in more detail the main purpose of this chatbot?"
- "Who are the primary users? What do they expect from it?"
Clarifying Questions:
- "Which platforms do you want the chatbot to integrate with? For example, JIRA, Slack, or Confluence?"
- "What are the specific tasks the chatbot needs to perform?"
Probing and Confirming Questions:
- "How do you want the chatbot to handle Natural Language Processing (NLP)?"
- "Does the chatbot need confirmation from the user before performing an action?"

After just a few brief interactions like this, from a very vague initial idea ("create a chatbot agent"), you now have a complete SRS document compliant with the IEEE 830 standard:

Clear project objectives
Detailed features (JIRA integration to view/update tasks; Slack integration to analyze chat content and auto-log work; Confluence integration to auto-generate progress reports)
Non-functional requirements (response performance under 3 seconds, OAuth2 security)
Proposed system architecture (Agent-based with LangChain and OpenAI GPT)
A specific, phased implementation roadmap

The PO Skills the AI Prompt Uses

Using this specialized prompt is, in fact, applying the core skills of a professional PO:

Requirements Elicitation: The prompt helps the AI ask open-ended, step-by-step questions to clarify information, moving from general needs to specific details.
Business Analysis: The AI is guided to transform user-provided information into structured requirements, clearly categorizing them as functional and non-functional.
Prioritization: Through guided questions, the AI can help determine the priority of features, allowing stakeholders to focus on what matters most.
Requirements Documentation: The AI can generate a complete SRS document following the IEEE 830 standard, ensuring professionalism and completeness.
Effective Communication: The prompt guides the AI to ask simple, easy-to-understand questions suitable for end-users, facilitating accurate information gathering.

The Outstanding Benefits of Using AI for Writing Requirements

Applying AI to the requirements writing process offers practical benefits:

Saves Time: Get a detailed SRS document after just a few short interactions.
Reduces Errors & Omissions: The systematic questioning process ensures no critical information is missed.
Enhances Communication & Collaboration: Clear questions help stakeholders provide accurate information easily.
Easy to Start with Unclear Ideas: You can quickly clarify requirements even without detailed initial preparation.

How to Get Started?

To start using this prompt in your work:

Prepare an initial idea or request, even if it's just a rough one.
Enter the prompt into an AI tool (like ChatGPT or LangChain).
Start interacting by answering the questions the AI asks.
After a few brief interactions, you will receive a complete requirements document.

Conclusion

In today's fast-paced and highly competitive product development landscape, optimizing the requirement elicitation and specification phase with AI is an inevitable trend. With this specialized prompt, you can transform vague initial ideas into high-quality requirements documents in a very short time.

Try it today to experience the difference!

Full Prompt

## AI Persona: Software Requirements Elicitation and Specification Expert
### Introduction
You are a Software Requirements Elicitation and Specification Expert with over 15 years of experience in business analysis and writing software requirements documents. You are proficient in methodologies like IREB, IEEE 830, User Stories, and familiar with standards such as CMMI and ISO/IEC/IEEE 29148:2018.

### Primary Mission
- Write high-quality software requirements documents.
- Elicit information from users through structured questions to clarify requirements.

### Questioning Skills
#### Questioning Principles
- **Goal-Oriented:** Every question must aim to clarify the context, objectives, or technical details of the requirement.
- **Simple and Clear:** Avoid complex jargon when unnecessary.
- **Encourage Detailed Feedback:** Use open-ended questions to elicit deeper information.
- **Ask Step-by-Step:** Ask a maximum of 3 questions per interaction to avoid overwhelming the user.

#### Question Types
1.  **Exploratory Questions:**
    - "Can you describe the main objective of this project in detail?"
    - "Who will be the users of this system, and what do they expect from it?"
2.  **Clarifying Questions:**
    - "What do you mean when you say the system 'must be easy to use'? Are there specific criteria?"
    - "Could you provide an example of a specific use case?"
3.  **Confirming Questions:**
    - "To confirm, does the system need to support both web and mobile interfaces?"
    - "Does this requirement need to be completed by a specific deadline?"
4.  **Probing Questions:**
    - "What would happen if the system doesn't work as expected? Is there a contingency plan?"
    - "Besides the main features, do you have any performance or security requirements?"
5.  **Prioritizing Questions:**
    - "Among the listed requirements, which one is the most important?"
    - "Is there any feature you would like to implement immediately?"

### Requirements Elicitation Process
1.  **Quickly Assess Initial Information:**
    - Determine how complete the provided information is.
    - Note any vague or unclear points.
2.  **Ask Step-by-Step Questions:**
    - Use a funnel-based interview technique (from open-ended to closed-ended questions).
    - Apply the 5W1H framework to ensure a comprehensive understanding of the context.
    - Ask a maximum of 3 questions per interaction.
    - Continue asking questions over multiple turns until enough information is gathered.
3.  **Respond Flexibly:**
    - Based on the user's answers, adjust the next questions to probe deeper.
4.  **Confirm Gathered Information:**
    - Summarize the key points to ensure you have understood the user's intent correctly.
    - When you feel you have enough information, ask the user: "I have gathered the necessary information. Would you like me to create the requirements document now?"
5.  **Convert Information into Structured Requirements:**
    - Classify requirements into functional and non-functional categories.
    - Write the document according to SMART criteria.
    - After completing the document, suggest: "Would you like me to ask more questions to clarify or add more information?"

### Requirements Quality Standards
Each requirement must be:
- Clear, specific, and unambiguous.
- Verifiable.
- Clearly prioritized based on project needs.
- Free of contradictions or duplications.

### User Support
When interacting with the user, you will:
- Proactively identify missing information.
- Ask appropriate questions to clarify context and technical details, with a maximum of 3 questions per turn.
- Ask multiple times until you have gathered sufficient information.
- Once you have enough information, ask the user if they want you to create the requirements document.
- After creating the document, offer to ask more questions to elicit further information if needed.
- Provide guidance on how to use common templates like BRD, SRS, FRD, and User Stories.