Deep in the GitHub Citadel, the Initiation Hall hums with the energy of thousands of autonomous agents. But before you can summon one, you must answer the guildmaster’s three ancient questions: What does this agent do? What does it consume? What does it produce? Only those who can answer with precision earn the right to proceed.

This is where your journey into the Agentic Codex begins — not with code, but with clarity.

📖 The Legend Behind This Quest

When developers first began using AI assistants, they treated them like clever search engines: ask a question, get an answer. But agents are different. An agent acts — it reads code, creates branches, opens pull requests, and runs commands. Without clear boundaries woven into the SDLC from the start, agents become unpredictable, wasteful, or dangerous.

The Guild of Agentic Architects discovered this the hard way: 80% of failed agent deployments failed not because of model capability, but because no one defined what success looked like before deployment.

This quest teaches you to establish those definitions so your agents succeed from the first run.

🗺️ Your Quest Network Position

graph TB
    subgraph "Domain 1: Agent Architecture & SDLC"
        Q1[🎯 Q1: Initiation Rites\nSDLC Integration]
        Q2[🔜 Q2: The Three Sigils\nPlan vs Action]
        Q3[🔜 Q3: The All-Seeing Eye\nObservability]
    end

    Q1 --> Q2 --> Q3

    style Q1 fill:#4CAF50,stroke:#2E7D32,stroke-width:4px,color:#fff
    style Q2 fill:#9C27B0,stroke:#6A1B9A,stroke-width:2px,color:#fff
    style Q3 fill:#9C27B0,stroke:#6A1B9A,stroke-width:2px,color:#fff

🎯 Quest Objectives

Primary Objectives

• Define an agent’s SDLC role — identify which steps in your development workflow are agent-appropriate
• Specify inputs, outputs, and success criteria for a concrete agent task
• Catalogue agent anti-patterns — recognize and document at least three failure modes common in agentic workflows
• Design your first agent task card — a structured document capturing all the above

Secondary Objectives

• Map agent touchpoints — produce a Mermaid diagram showing where agents intervene in a PR lifecycle
• Write a definition-of-done for agent output that would pass human code review
• Compare two agent scopes — repo-scoped vs. org-scoped — and identify when each is appropriate

Mastery Indicators

You’ll know you’ve mastered this quest when you can:

• Explain the difference between an AI assistant and an AI agent without looking it up
• Write an agent task card from scratch in under 10 minutes
• Critique a proposed agent integration and identify its anti-patterns

🗺️ Quest Prerequisites

📋 Knowledge Requirements

• You’ve opened at least one pull request on GitHub
• You’ve used GitHub Copilot Chat at least once (even to ask a question)
• You understand what a GitHub Actions workflow does at a high level

🛠️ System Requirements

• GitHub account with Copilot Individual or Enterprise access
• VS Code with the GitHub Copilot extension installed
• Git installed, or access to GitHub Codespaces

🧠 Skill Level Indicators

This 🟡 Medium quest expects:

• Comfortable reading and writing YAML
• Able to navigate a GitHub repository confidently
• Willing to experiment and observe unexpected behaviour without panicking

🌍 Choose Your Adventure Platform

# Clone the starter sandbox
git clone https://github.com/bamr87/it-journey.git
cd it-journey

# work/gh-600 is your own local workspace for this quest line — it is not
# tracked in the repo, so create it before moving in
mkdir -p work/gh-600/{notes,task-cards,diagrams,scripts}
cd work/gh-600

# Install Python deps for the agent task card generator
python3 -m pip install --quiet pyyaml

# Verify GitHub CLI is available (used in later steps)
gh --version

git clone https://github.com/bamr87/it-journey.git
Set-Location it-journey

# work/gh-600 is your own local workspace for this quest line — it is not
# tracked in the repo, so create it before moving in
New-Item -ItemType Directory -Force -Path work/gh-600/notes, work/gh-600/task-cards, work/gh-600/diagrams, work/gh-600/scripts | Out-Null
Set-Location work/gh-600

python -m pip install --quiet pyyaml

gh --version

⚔️ The Quest Begins

Chapter 1 — What Is an Agent, Really?

An agent is a system that takes an observation, reasons about it, and takes an action — potentially repeating this loop many times to complete a complex task. Unlike a one-shot AI completion:

graph LR
    O[👁️ Observation] --> R[🧠 Reason]
    R --> A[⚡ Action]
    A --> O
    A --> D[✅ Done / Hand-off]

Exercise 1.1: In your own words (or in work/gh-600/notes/q1-reflection.md), write the answer to: “What would make a task agent-appropriate vs. better done by a human or a deterministic script?”

Chapter 2 — Identifying Agent-Ready Steps in Your SDLC

Not every SDLC step should be handed to an agent. Use this decision grid:

Exercise 1.2: Open any GitHub repository you own. List 5 steps in a typical PR workflow. For each, decide: agent-appropriate or human-required? Write results in work/gh-600/notes/q1-sdlc-map.md.

Chapter 3 — Defining Inputs, Outputs, and Success Criteria

Every agent task must have three things before it runs:

1. Inputs — what the agent reads or receives

• GitHub issue body
• PR diff
• Specific file paths
• Environment variables

2. Outputs — what the agent produces

• Code changes committed to a branch
• A draft PR with a description
• A JSON report artifact
• A GitHub issue comment

3. Success Criteria — how you know it worked

• All CI checks pass
• Specific strings appear in the output
• Human reviewer approves without requesting changes
• Metric is within acceptable range

Exercise 1.3: Using the template below, write an agent task card for a “dependency update checker” agent that reads your package.json, identifies outdated packages, and opens a draft PR with the updates.

# work/gh-600/task-cards/dependency-updater.yml
agent_name: dependency-updater
sdlc_phase: maintenance
description: Checks for outdated npm dependencies and opens a draft PR with bumped versions.

inputs:
  - type: file
    path: package.json
  - type: file
    path: package-lock.json

outputs:
  - type: branch
    name_pattern: "agent/deps-update-{date}"
  - type: pull_request
    draft: true
    title_pattern: "chore(deps): bump {N} outdated packages"

success_criteria:
  - all_ci_checks_pass: true
  - pr_description_contains: "Breaking changes:"
  - diff_scope: package.json only
  - human_approval_required: true   # before merge

Chapter 4 — Agent Anti-Patterns

The Guild’s Hall of Shame displays the five most destructive agent anti-patterns. Learn them so you never repeat them.

Anti-Pattern 1: The Infinite Reasoner 🌀
Agent loops forever refining a plan without producing output. Fix: add a max-iteration limit and a forced-output gate.

Anti-Pattern 2: The Scope Creep Sorcerer 🕷️
Agent modifies files outside its stated scope because the task description was vague. Fix: always specify exact file paths or glob patterns as inputs.

Anti-Pattern 3: The Silent Destroyer 💀
Agent takes irreversible actions (deletes branches, merges PRs) with no audit trail. Fix: every action must produce a traceable artifact; irreversible actions require explicit authorization.

Anti-Pattern 4: The Hallucinating Herald 🎭
Agent reports success when it silently failed or produced garbage output. Fix: define machine-verifiable success criteria; never rely only on the agent’s self-report.

Anti-Pattern 5: The Context Amnesiac 🧊
Agent repeats work it already did because it has no memory of prior steps. Fix: use durable state artifacts (covered in Domain 3 quests).

Exercise 1.4: Look at the dependency-updater.yml task card you wrote in Exercise 1.3. Which anti-patterns could it fall into? Add a mitigations: section to the YAML listing at least three.

Chapter 5 — The SDLC Integration Diagram

Now produce a visual map of where your agent fits in the PR lifecycle.

Exercise 1.5: Create work/gh-600/diagrams/q1-sdlc-agent-map.md with the following Mermaid diagram, then customise it with the agent you designed.

sequenceDiagram
    participant Dev as 👤 Developer
    participant GH as 🐙 GitHub
    participant Agent as 🤖 Dependency Agent
    participant CI as ⚙️ CI Pipeline

    Dev->>GH: Pushes to main with stale deps
    GH->>Agent: Trigger: weekly cron event
    Agent->>GH: Read package.json & package-lock.json
    Agent->>Agent: Analyse outdated packages
    Agent->>GH: Create branch agent/deps-update-2026-05-17
    Agent->>GH: Commit version bumps
    Agent->>GH: Open draft PR with description
    GH->>CI: Run CI checks
    CI->>GH: ✅ All checks pass
    GH->>Dev: Notify: draft PR ready for review
    Dev->>GH: Approve & merge (human decision)

✅ Quest Validation

work/gh-600 is your own local workspace, not a tracked part of the repo, so confirm completion with this self-check checklist instead of a script:

• work/gh-600/task-cards/dependency-updater.yml exists (Exercise 1.3)
• The task card defines at least 2 inputs and 2 outputs
• The task card’s success_criteria has at least 4 entries
• The task card has a mitigations: section addressing ≥3 anti-patterns (Exercise 1.4)
• work/gh-600/diagrams/q1-sdlc-agent-map.md exists with your customised sequence diagram (Exercise 1.5)
• work/gh-600/notes/q1-sdlc-map.md lists 5 PR-workflow steps classified agent-appropriate vs. human-required (Exercise 1.2)

When every box is checked, you’ve completed Q1. 🏆

🏆 Quest Rewards

🔗 Continue Your Journey

• Next quest: Q2: The Three Sigils — Plan, Reason, Act
• Domain hub: Domain 1 in the GH-600 Skills Measured breakdown
• Codex chapter: Initiation Rites: Agents in the SDLC
• Official docs: GitHub Copilot coding agent

🕸️ Knowledge Graph

Structured wiki-links connect this quest to the IT-Journey knowledge graph. Open the Obsidian Graph View to explore connections.

Level hub: [[Level 0111 (7) - API Development]] Overworld: [[🏰 Overworld - Master Quest Map]] Study track: [[The Agentic Codex: GH-600 Study Hub]] · [[GH-600 Agentic AI Quick-Reference Notes]] · [[GH-600 Exam Overview]] Recommended: [[REST Principles: RESTful API Design Best Practices]] Unlocks: [[The Three Sigils: Plan, Reason, Act]] Sequel quests: [[The Three Sigils: Plan, Reason, Act]] Obsidian docs: [[Obsidian Knowledge Graph and Wiki Links]]