# How to Configure AI-DLC Rule Loading for Kiro IDE

> Learn to configure AI-DLC rule loading for Kiro IDE. Consolidate rules in a markdown file within your project for automatic loading and streamline your development workflow.

- Repository: [Amazon Web Services - Labs/aidlc-workflows](https://github.com/awslabs/aidlc-workflows)
- Tags: how-to-guide
- Published: 2026-05-09

---

**AI-DLC rule loading for Kiro IDE works by writing a consolidated markdown file to a `.kiro/steering/` directory inside your project workspace, which the Kiro IDE automatically monitors and loads into its Steering Files panel.**

The `awslabs/aidlc-workflows` repository provides adapter implementations that automate this configuration, injecting AI-Driven Development Life-Cycle rules directly into the Kiro development environment. Understanding this mechanism enables you to manually configure, troubleshoot, or extend the rule-loading behavior for both IDE and CLI workflows.

## The Steering Directory Architecture

Kiro IDE consumes AI-DLC rules through a specialized directory structure that acts as a bridge between the rule engine and the IDE's AI assistant.

### Directory Location and Structure

The system expects steering files to reside at `.kiro/steering/` relative to your project root. When the **KiroAdapter** initializes, it performs the following operations in [`scripts/aidlc-evaluator/packages/ide-harness/src/ide_harness/adapters/kiro.py`](https://github.com/awslabs/aidlc-workflows/blob/main/scripts/aidlc-evaluator/packages/ide-harness/src/ide_harness/adapters/kiro.py):

1. Detects the absolute workspace path
2. Creates `workspace / ".kiro" / "steering"` using `mkdir(parents=True, exist_ok=True)`
3. Serializes the complete AI-DLC rule bundle into a single file named [`aidlc-rules.md`](https://github.com/awslabs/aidlc-workflows/blob/main/aidlc-rules.md)
4. Writes the file to the steering directory for immediate consumption

The rule source originates from `aidlc-rules/aws-aidlc-rules/` in the repository, containing the full workflow definition that gets packaged into the single markdown output.

### File Format Requirements

Kiro expects a single markdown file named exactly [`aidlc-rules.md`](https://github.com/awslabs/aidlc-workflows/blob/main/aidlc-rules.md) placed in the steering directory. This file contains the concatenated contents of the entire rule bundle, making the AI-DLC methodology available to the AI assistant during development sessions.

## Configuring AI-DLC Rules Manually

You can replicate the adapter's behavior manually using command-line tools or scripts.

### Bash Configuration

Run these commands in your project root to set up the steering directory manually:

```bash

# Create the steering directory structure

mkdir -p .kiro/steering

# Copy the rule bundle (adjust path to your downloaded rules)

cp -R ~/Downloads/aidlc-rules/aws-aidlc-rules .kiro/steering/

# Concatenate all markdown rules into the required single file

cat > .kiro/steering/aidlc-rules.md <<'EOF'
$(cat .kiro/steering/aws-aidlc-rules/core-workflow.md)
$(cat .kiro/steering/aws-aidlc-rules/extensions/*.md)
EOF

```

### Python Automation

For programmatic configuration, use this Python implementation that mirrors the **KiroAdapter** logic found in the source code:

```python
from pathlib import Path
import shutil
import logging

log = logging.getLogger(__name__)

def install_aidlc_rules(workspace: Path, rules_src: Path) -> None:
    """
    Install AI-DLC rules for Kiro IDE/CLI consumption.
    
    Parameters
    ----------
    workspace: Path
        Root of the project where Kiro will run.
    rules_src: Path
        Folder containing the pre-generated AI-DLC rule bundle
        (e.g., 'aws-aidlc-rules/' from the repository).
    """
    steering_dir = workspace / ".kiro" / "steering"
    steering_dir.mkdir(parents=True, exist_ok=True)

    # Copy the complete rule bundle for reference

    dest_bundle = steering_dir / "aws-aidlc-rules"
    if dest_bundle.exists():
        shutil.rmtree(dest_bundle)
    shutil.copytree(rules_src, dest_bundle)

    # Combine all markdown files into the single steering file

    combined_md = steering_dir / "aidlc-rules.md"
    with combined_md.open("w", encoding="utf-8") as out:
        for md_file in sorted(dest_bundle.rglob("*.md")):
            out.write(md_file.read_text(encoding="utf-8"))
            out.write("\n\n")
    log.info("AI-DLC rules written to %s", combined_md)

# Example usage

install_aidlc_rules(Path.cwd(), Path.home() / "Downloads/aidlc-rules/aws-aidlc-rules")

```

## Verification Methods

After configuring the steering directory, verify that Kiro correctly loads the AI-DLC rules.

### Kiro IDE Verification

Open the Kiro IDE and navigate to the **Steering Files** panel. You should see [`aidlc-rules.md`](https://github.com/awslabs/aidlc-workflows/blob/main/aidlc-rules.md) listed among the active steering files, indicating that the AI assistant has access to the AI-DLC workflow rules.

### Kiro CLI Verification

For headless or automated environments using the **KiroCLIAdapter** (implemented in [`scripts/aidlc-evaluator/packages/cli-harness/src/cli_harness/adapters/kiro_cli.py`](https://github.com/awslabs/aidlc-workflows/blob/main/scripts/aidlc-evaluator/packages/cli-harness/src/cli_harness/adapters/kiro_cli.py)), run the following command:

```bash
kiro-cli
/context show

```

Look for [`.kiro/steering/aidlc-rules.md`](https://github.com/awslabs/aidlc-workflows/blob/main/.kiro/steering/aidlc-rules.md) in the output to confirm the rules are loaded into the session context.

## Summary

- **AI-DLC rule loading for Kiro IDE** requires a `.kiro/steering/` directory containing an [`aidlc-rules.md`](https://github.com/awslabs/aidlc-workflows/blob/main/aidlc-rules.md) file.
- The **KiroAdapter** and **KiroCLIAdapter** automate this by creating the directory structure and concatenating the rule bundle from `aidlc-rules/aws-aidlc-rules/`.
- Manual configuration involves creating `.kiro/steering/` and writing the consolidated markdown file using bash or Python scripts.
- Verify IDE integration using the **Steering Files** panel, or verify CLI integration using the `/context show` command.

## Frequently Asked Questions

### What file format does Kiro expect for AI-DLC rules?

Kiro expects a single markdown file named [`aidlc-rules.md`](https://github.com/awslabs/aidlc-workflows/blob/main/aidlc-rules.md) placed in the `.kiro/steering/` directory. This file should contain the concatenated contents of all AI-DLC rule definitions, allowing the IDE to present them as a unified steering context to the AI assistant.

### Where does the Kiro IDE look for steering files?

The Kiro IDE monitors the `.kiro/steering/` directory located at the project workspace root. According to the implementation in [`kiro.py`](https://github.com/awslabs/aidlc-workflows/blob/main/kiro.py), the adapter creates this path using `workspace / ".kiro" / "steering"` and the IDE automatically detects any markdown files placed within this folder.

### Can I configure AI-DLC rules for Kiro CLI as well?

Yes, the **KiroCLIAdapter** in [`scripts/aidlc-evaluator/packages/cli-harness/src/cli_harness/adapters/kiro_cli.py`](https://github.com/awslabs/aidlc-workflows/blob/main/scripts/aidlc-evaluator/packages/cli-harness/src/cli_harness/adapters/kiro_cli.py) implements identical rule-loading logic for headless automation. Both adapters create the same [`.kiro/steering/aidlc-rules.md`](https://github.com/awslabs/aidlc-workflows/blob/main/.kiro/steering/aidlc-rules.md) file structure, making the rules available to the Kiro CLI via the `/context show` command.

### How do I update AI-DLC rules without restarting Kiro?

Simply overwrite the [`.kiro/steering/aidlc-rules.md`](https://github.com/awslabs/aidlc-workflows/blob/main/.kiro/steering/aidlc-rules.md) file with the updated rule content. The Kiro IDE monitors the steering directory for changes, so updated rules become available immediately without requiring a restart of the development environment.