What Artifacts Each Phase Generates in aidlc-docs: A Complete Reference

The AI-DLC workflow generates structured Markdown artifacts exclusively under the aidlc-docs/ folder, with each phase producing specific documentation sets that serve as the source of truth for downstream gates and AI-driven generation.

The awslabs/aidlc-workflows repository implements a structured documentation-driven approach to AI-assisted software development. Understanding what artifacts each phase generates in aidlc-docs is critical for navigating the Inception, Construction, and Operations phases, as these Markdown files drive automated evaluations and subsequent code generation gates.

Inception Phase Artifacts

The Inception phase establishes the foundational documentation for the AI-DLC workflow. According to the source rules in aidlc-rules/aws-aidlc-rule-details/inception/, this phase populates the aidlc-docs/inception/ directory with five primary sub-folders: reverse-engineering/, requirements/, application-design/, user-stories/, and plans/.

Reverse-Engineering Documentation

The reverse-engineering sub-phase generates high-level architectural context. The defining rules in reverse-engineering.md mandate the creation of:

• reverse-engineering/business-overview.md – Business context and operational boundaries
• reverse-engineering/architecture.md – High-level system architecture documentation

Requirements Analysis

Governed by aidlc-rules/aws-aidlc-rule-details/inception/requirements-analysis.md, this sub-phase produces:

• requirements/requirements.md – Fully-qualified functional requirements specifications
• requirements/requirement-verification-questions.md – Verification Q&A pairs for validating each requirement

Application Design

The application design artifacts, defined in application-design.md, consolidate component architecture:

• application-design/components.md – Component catalog inventory
• application-design/component-methods.md – Service method definitions
• application-design/services.md – Service contracts and interfaces
• application-design/component-dependency.md – Dependency matrix between components
• application-design/application-design.md – Consolidated design document

User Stories and Planning

The final Inception outputs include narrative documentation and execution roadmaps:

• user-stories/stories.md – User story narratives
• user-stories/personas.md – Actor persona definitions
• plans/unit-of-work-plan.md – Granular work breakdown structure
• plans/execution-plan.md – Phase execution roadmap

Construction Phase Artifacts

The Construction phase operates within aidlc-docs/construction/ and organizes output by unit name ({unit-name}/). This phase is governed by rule files in aidlc-rules/aws-aidlc-rule-details/construction/ and generates functional designs, NFR documentation, infrastructure plans, and build instructions.

Functional Design per Unit

Each unit receives detailed functional specifications under construction/{unit-name}/functional-design/:

• functional-design/business-logic-model.md – Business rules and process flows
• functional-design/domain-entities.md – Data models and entity relationships
• functional-design/frontend-components.md – UI component specifications (if applicable)

Non-Functional Requirements and Design

Under construction/{unit-name}/, the NFR sub-phases produce architectural constraints:

• nfr-requirements/nfr-requirements.md – Performance, security, and scalability requirements
• nfr-requirements/tech-stack-decisions.md – Technology selection rationale
• nfr-design/nfr-design-patterns.md – Patterns for satisfying non-functional constraints
• nfr-design/logical-components.md – Logical decomposition of NFR-driven components

Infrastructure and Deployment Design

Infrastructure artifacts reside under construction/{unit-name}/infrastructure-design/:

• infrastructure-design/infrastructure-design.md – Core infrastructure specifications
• infrastructure-design/deployment-architecture.md – Deployment topology and shared infrastructure

Code Documentation

Under construction/{unit-name}/code/:

• code/{unit-name}.md – Generated source documentation (Markdown format only, never source code files)

Build and Test Instructions

At the construction/ root level, separate from unit-specific folders:

• build-and-test/build-instructions.md – Compilation and packaging steps
• build-and-test/unit-test-instructions.md – Unit testing procedures
• build-and-test/integration-test-instructions.md – Integration testing protocols
• build-and-test/build-and-test-summary.md – Consolidated testing overview including performance, contract, security, and e2e tests

Construction Planning Documents

Also at the construction/ root:

• plans/{unit-name}-functional-design-plan.md – Functional design roadmap per unit
• plans/{unit-name}-code-generation-plan.md – Code generation strategy per unit

Operations Phase Artifacts

The Operations phase currently serves as a placeholder for future expansion. As defined in aidlc-rules/aws-aidlc-rules/core-workflow.md (see line 531), the aidlc-docs/operations/ folder exists but contains no artifacts. The AI-DLC specification reserves this directory for future deployment-specific documentation such as CI/CD pipelines, observability dashboards, and runtime policies.

Artifact Generation Implementation

The aidlc-evaluator scripts materialize these artifacts using template-based writers. As implemented in the evaluation harness, helper functions construct paths under aidlc-docs/ and render Markdown content:

# Example from aidlc-evaluator (pseudocode)

def write_requirements():
    path = Path("aidlc-docs/inception/requirements/requirements.md")
    content = render_template("requirements.md", data=requirements)
    path.write_text(content)

def write_execution_plan():
    path = Path("aidlc-docs/inception/plans/execution-plan.md")
    content = render_template("execution-plan.md", data=plan)
    path.write_text(content)

These write_* helpers are invoked by the rule engine after each sub-task completes, ensuring every Markdown file defined in the phase specifications is produced. The evaluator reads the generated tree—as specified in scripts/aidlc-evaluator/docs/file-structure.md—to perform gate reviews, scoring, and optional "golden" comparisons against expected documentation.

Summary

• The Inception phase generates foundational documentation including business overviews, requirements specifications, component designs, user stories, and execution plans under aidlc-docs/inception/
• The Construction phase produces unit-specific functional designs, NFR documentation, infrastructure plans, code documentation, and build instructions under aidlc-docs/construction/
• All artifacts are Markdown files exclusively; actual source code resides separately in the workspace/ root
• The Operations phase is currently a placeholder for future CI/CD and observability artifacts in aidlc-docs/operations/
• Rule definitions in aidlc-rules/aws-aidlc-rule-details/ govern the specific content and structure of each artifact

Frequently Asked Questions

What distinguishes Inception phase artifacts from Construction phase artifacts in aidlc-docs?

Inception phase artifacts define what to build—capturing business context, requirements, and high-level architecture—while Construction phase artifacts specify how to build it—detailing functional logic, NFR compliance, infrastructure, and testing protocols. The Inception outputs drive planning gates, whereas Construction outputs drive implementation and build gates.

Where does the aidlc-workflows repository store generated artifacts?

All generated documentation resides strictly under the aidlc-docs/ folder at the repository root, with sub-folders organized by phase (inception/, construction/, operations/). Application source code and build outputs are stored separately in the workspace/ directory, never mixed with the Markdown documentation tree.

Does the Construction phase generate actual executable source code files?

No. According to the code-generation rules in aidlc-rules/aws-aidlc-rule-details/construction/code-generation.md, the Construction phase generates only Markdown documentation describing the code (stored as code/{unit-name}.md). The workflow intentionally separates documentation generation from source file creation to maintain the aidlc-docs/ tree as a readable, evaluable artifact independent of implementation files.

Which files define the complete specification for artifact generation?

The authoritative specifications reside in:

• aidlc-rules/aws-aidlc-rules/core-workflow.md – High-level phase diagrams and folder layouts
• aidlc-rules/aws-aidlc-rule-details/inception/* – Inception artifact definitions
• aidlc-rules/aws-aidlc-rule-details/construction/* – Construction artifact definitions
• scripts/aidlc-evaluator/docs/file-structure.md – Runtime directory structure validation

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}