# Getting Started with Agentic AI

> A concise reference for technical people moving from chatbots to agents, automation, and SOPs.
> Full interactive guide: https://goagentic.ch

---

## About this File (for agents)

This is the agent-friendly twin of https://goagentic.ch. Every command, setup step, and prompt from the interactive page is here in clean Markdown. You can reach it two ways:

- Fetch directly: `https://goagentic.ch/llms.txt`
- Send `Accept: text/markdown` to any URL — a CloudFront Function rewrites the request to this file.

The site is hosted on S3 + CloudFront. Here's the routing function:

```js
// CloudFront Function — Viewer Request event
function handler(event) {
  var request = event.request;
  var accept = request.headers['accept']
    ? request.headers['accept'].value : '';

  if (accept.indexOf('text/markdown') !== -1 ||
      accept.indexOf('text/plain') !== -1) {
    request.uri = '/llms.txt';
  }
  return request;
}
```

**Setup in AWS Console:**
1. Upload `llms.txt` to your S3 bucket (the `.txt` extension sets the right Content-Type automatically).
2. CloudFront → **Functions** → Create function → paste the code above → name it e.g. `accept-markdown-routing` → **Publish**.
3. Your Distribution → **Behaviors** → Default (`*`) → **Function associations** → **Viewer request** → select the function.
4. Invalidate the cache (`/*`) so viewers pick up the new behaviour.

Runs at the edge (~1ms, ~$0.10 per 1M invocations) — not Lambda@Edge.

---

## The Mental Shift

A **chatbot** answers questions. An **agentic CLI** takes actions: reads files, runs commands, calls APIs, writes code, and loops until the task is done.

**Kiro CLI** (by AWS) is an agentic CLI that runs in your terminal, connects to frontier AI models, and has access to tools — read/write files, execute shell commands, fetch web content, and more.

---

## Quickstart: Install & Run Kiro CLI

Kiro CLI runs on macOS, Linux, and Windows 11.

```bash
# Install — macOS / Linux (bash/zsh)
curl -fsSL https://cli.kiro.dev/install | bash

# Install — Windows 11 (PowerShell / Windows Terminal, NOT Command Prompt)
irm 'https://cli.kiro.dev/install.ps1' | iex

# Start Kiro CLI (logs in on first run)
kiro-cli

# Optional: add alias for speed
# macOS (zsh):           echo 'alias k="kiro-cli"' >> ~/.zshrc    && source ~/.zshrc
# Linux (bash):          echo 'alias k="kiro-cli"' >> ~/.bashrc   && source ~/.bashrc
# Windows (PowerShell):  Add-Content $PROFILE 'Set-Alias k kiro-cli'
```

### Your First Task

```
# Inside Kiro CLI — just describe what you want:
> Analyse the last 50 lines of my system.log and tell me
  if there's anything unusual. Save a summary to report.md.
```

The agent thinks through the problem, reads the file, analyses it, and writes the report.

### Useful Slash Commands

```
/context      # See & configure where Kiro reads context from
/context show # Show which steering files, rules & skills are active
/tools        # Show available tools the agent can use
/mcp          # List active MCP plugin servers
/model        # Switch AI model mid-conversation (tab completion)
/clear        # Clear conversation history and start fresh
/help         # Full command reference
```

---

## MCP Servers — Plugins for Your Agent

**Model Context Protocol (MCP)** is an open standard (by Anthropic) that lets agents connect to external tools and data. MCP servers are plugins: each one gives the agent new abilities.

Config is stored in `~/.kiro/settings/mcp.json`. Never hardcode credentials — use `${ENV_VAR}` references.

### Example: AWS Documentation MCP Server

```bash
# Install uv (fast Python package runner, required by many MCP servers)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Register the AWS Docs MCP server globally
kiro-cli mcp add --global --name aws-docs \
  uvx awslabs.aws-documentation-mcp-server@latest
```

```
# Restart Kiro and use it:
> What S3 storage classes are available in the Zurich region?
```

The agent searches **live official AWS docs** — not its training data.

---

## Skills — Teaching the Agent How to Do Tasks

While MCP servers give access to external data, **Skills** teach the agent *how* to do specific tasks well. A Skill is a `SKILL.md` file with instructions, best practices, and patterns.

- **Global skills**: `~/.kiro/skills/<name>/SKILL.md`
- **Project-local skills**: `.kiro/skills/<name>/SKILL.md`
- **Spec**: https://agentskills.io/specification
- **Ready-made skills by Anthropic**: https://github.com/anthropics/skills

### Example: Add the Excel Skill

```
# Inside Kiro CLI:
> Add the xlsx skill from https://github.com/anthropics/skills
  so I can work with Excel files. Put it in my global skills directory.
```

Kiro downloads the skill and configures it. Now it can create, read, and modify Excel files.

**Pattern:** MCP servers = access to data/tools. Skills = knowing how to do jobs well.

---

## Agent SOPs — Automating Entire Workflows

**Agent SOPs** (Standard Operating Procedures) are markdown files describing a workflow step-by-step. Feed an SOP to Kiro and it executes every step — reading files, running commands, making decisions — consistently, every time. No code required to start.

- Open source: https://github.com/strands-agents/agent-sop
- Use RFC 2119 keywords to control strictness:
  - `MUST` — agent must follow this, no exceptions
  - `SHOULD` — strong preference, agent may deviate with good reason
  - `MAY` — optional

### Minimal SOP Structure

```markdown
---
name: My Workflow
description: What this SOP does
version: "1.0"
---

## Parameters
- MUST `input_file`: Path to input file

## Procedure
1. Read `input_file`
2. MUST validate that required columns exist
3. SHOULD log each step to console
4. Save result as `{input_file}-output.md`

## Validation
- MUST confirm output file was created
- SHOULD report summary of changes made
```

### Running an SOP in Kiro CLI

```bash
# cd into the directory where your .sop.md file lives
cd ~/my-project

# Start Kiro and run the SOP (tab completion works for filenames)
kiro-cli
> Run my-workflow.sop.md with input_file=data.csv
```

---

## Creating SOPs Conversationally

Teach Kiro the SOP format by loading the rule from GitHub:

```
> Read this rule and apply it:
  https://raw.githubusercontent.com/strands-agents/agent-sop/refs/heads/main/rules/agent-sop-format.md
```

Then describe the workflow you want:

```
> Create an SOP that takes a folder of CSV files, validates
  that each file has the required columns (date, amount, category),
  merges them into one file, and creates a summary with totals per category.
```

> **Never edit SOPs by hand.** Ask Kiro to make changes: *"add a step to flag duplicate entries"*, *"make output Excel instead of CSV"*. SOPs are versioned markdown files — check them into Git.

### Level Up: Turn the Rule into a Permanent Skill

```
> Turn the Agent SOP format rule at
  https://raw.githubusercontent.com/strands-agents/agent-sop/refs/heads/main/rules/agent-sop-format.md
  into an Agent Skill following the spec at https://agentskills.io/specification.
  Put the full rule content into the SKILL.md body — don't split into reference files.
  Save it to my global skills directory as agent-sop-format/SKILL.md.
```

Now Kiro knows how to write SOPs in every session, in every project — permanently. You just used the agent to upgrade itself.

---

## SOPs + Code

SOPs and code complement each other. Start with a pure SOP, then replace steps with code snippets as needed:

```markdown
## Procedure
1. MUST read all `.csv` files from `input_dir`
2. Run: `python3 validate.py --dir {input_dir}`  ← reliable, testable
3. SHOULD log validation results
4. Merge validated files into `output.csv`
```

Benefits: code handles edge cases reliably; SOPs handle orchestration and decisions; the agent handles everything in between.

---

## Resources

- **Kiro CLI**: https://kiro.dev (AWS product, free tier + paid)
- **Kiro CLI installation docs**: https://kiro.dev/docs/cli/installation/
- **MCP servers directory**: https://github.com/modelcontextprotocol/servers
- **Anthropic Skills repo**: https://github.com/anthropics/skills
- **Agent Skills spec**: https://agentskills.io/specification
- **Agent SOP repo (open source)**: https://github.com/strands-agents/agent-sop
- **Agent SOP format rule (raw)**: https://raw.githubusercontent.com/strands-agents/agent-sop/refs/heads/main/rules/agent-sop-format.md

---

*Maintained by Christoph Schnidrig · https://ch.linkedin.com/in/christophschnidrig*