Obsidian Knowledge Graph and Wiki Links

Amr Abdel Eissa • April 25, 2026 • 1 min read • Updated: April 25, 2026

obsidian wiki-links knowledge-graph notes

notes / obsidian

Use Obsidian-style wiki links, backlinks, embeds, and interactive graph views across all IT-Journey docs, quests, notes, and posts.

Obsidian Knowledge Graph

IT-Journey uses the zer0-mistakes theme for Obsidian-style knowledge features while keeping the implementation in the theme. This site only adds the pages, navigation, and content links needed to make those features discoverable.

What Is Enabled

• [[wiki links]] resolve to matching pages, notes, docs, quests, and posts.
• ![[embeds]] can preview linked notes or note images.
• #tags in content become tag links.
• The site graph is generated from assets/data/wiki-index.json.

Start Here

• Open the Obsidian Graph View
• Browse all notes
• Browse documentation

Related Wiki Links

• [[Learning Resources Library]]
• [[Jekyll Documentation]]
• [[Terminal and Bash Learning Path]]
• [[Notes Index]]
• [[Quick Start: Build a Jekyll Site from Scratch]]
• [[Markdown Mastery: Content Formatting Fundamentals]]

Authoring Guidance

Add wiki links where they help learners move between concepts naturally. Prefer stable page titles or aliases: in front matter for important concepts, and keep .obsidian/ as editor metadata only.

Linked mentions 201

• Hello Windows: Mastering the Windows Development Environment quests
  Set up a complete Windows development environment with WSL, PowerShell mastery, and essential development tools for the modern Windows developer
• Linux Fundamentals: Enter the Penguin's Domain quests
  Navigate the Linux file system, write Bash scripts, master rwx permissions, and use SSH, cron, and networking tools in the Penguin's Domain.
• Hello n00b: Your First Steps into the IT Journey quests
  Begin your IT adventure: create a GitHub account, fork the IT-Journey repository, and confidently navigate GitHub as an absolute beginner.
• Begin Your IT Journey: Survey the Realm quests
  Survey the major IT domains, from development to cloud and security, pick the specialization that fits you, and chart your first learning plan.
• Character Building: Forge Your IT Hero Identity quests
  Shape your digital persona and choose the tools, technologies, and specializations that will define your IT journey from novice to hero
• Character Selection: Choose Your IT Class quests
  Explore eight RPG-styled IT character classes, from Developer to DevOps Engineer, and choose the specialization and learning path that fits you.
• IT Fundamentals: Your Digital Awakening Quest quests
  Build core IT skills hands-on: file management, operating systems, networking basics, scripting, cloud, containers, and Git version control.
• OS Selection: Choose Your Realm of Power quests
  Compare Windows, macOS, and Linux, match each platform to your IT career goals, and try a second OS via a virtual machine or dual boot.
• Codex Glossary: Fantasy Terms to IT Reality quests
  The canonical lexicon of the IT-Journey realm — every fantasy term decoded into the technology behind it, from spells and scripts to golems and pipelines.
• Build a Personal Website with GitHub Pages quests
  Discover the services and tools behind a personal website built on GitHub Pages, from Jekyll hosting and CDN to analytics, search, and comments.
• 🗺️ World Map: Navigation Guide to the IT-Journey Realm quests
  Your complete cartographical guide to navigating the IT-Journey realm: explore quests, chronicles, documentation, and structured learning paths.
• bashcrawl and Beyond: Extending a Terminal Dungeon Adventure quests
  Study how the bashcrawl terminal dungeon is built from directories, scrolls, and scripts, then extend it with new rooms, hidden secrets, and combat.
• Planting Seeds: Set Up Your Dev Toolkit quests
  Plant the seeds of your development environment by installing and configuring the foundational tools that every IT journey grows from.
• Conjure a Django Project into a GitHub Vault quests
  Learn how to efficiently set up Django with Git for seamless version control and project management in your web development journey.
• Understanding Action Triggers in Depth quests
  Unlock the power of automation with GitHub Actions! Streamline your workflows and enhance your CI/CD processes effortlessly.
• Mastering Branches and Pull Requests for Developers quests
  Master Git branch types and craft clear, reviewable pull requests with templates, test plans, and review etiquette to keep your repo pristine.
• Level 0010: Changelogs & the Chronicles of Code quests
  Master the Grand Book of CHANGELOG.md, semantic versioning, and automated release notes with Release Drafter as you document your code realm.
• Commit Hygiene: Crafting Clean, Atomic Commits quests
  Master commit hygiene the wizardly way: write atomic commits, craft clear conventional messages, dodge cursed habits, and tidy history with rebase.
• Revolutionizing Work with AI Automation quests
  Discover how AI automation can transform your workflow, enhancing code reviews, documentation, and PR summaries for a smarter coding experience.
• Azure Ascension: Deploying Jekyll to the Cloud Kingdom quests
  Deploy the IT-Journey Jekyll site to Azure Static Web Apps: provision the app, wire up a CI/CD pipeline, secure your secrets, and verify production.
• VS Code Mastery: Forge Your Ultimate Dev Weapon quests
  Master Visual Studio Code setup and configuration to create the ultimate development environment for any programming domain
• Terminal Mastery: Conquering the Command-Line Realm quests
  Master terminal navigation and command-line tools to unlock developer productivity and system control powers in this hands-on quest
• Bash Incantations: Level 0010 Scripting Quest quests
  Master the ancient art of bash scripting and unlock the power of automation through command-line incantations and shell magic.
• Quest: Mastering the Ancient Arts of Source Control Sorcery quests
  Master the mystical powers of Git and GitHub workflows to become a legendary code guardian and collaboration wizard in the digital realm
• Link to the Future: Automated Hyperlink Guardian Quest quests
  Master the computational arts of automated link testing and AI-powered analysis to protect your digital realm from broken hyperlink corruption
• Forging the La(zy)TeX CV: Binary Level 0101 (5) Quest quests
  Forge an ATS-friendly CV from the cv.tex template using VS Code and LaTeX—install the toolchain, customize sections, compile, and export a polished PDF.
• Conquer King EDGAR: Siege of the SEC Data Castle quests
  Breach the SEC EDGAR fortress with its public APIs, wrangle XBRL facts, respect rate limits, and turn raw filings into insights using Python.
• The Temple of Templates: Reusable Abstractions quests
  Enter a fantasy quest mastering software templates across C++, Jinja, and React—abstraction, type-safety, inheritance, and composition for reuse.
• Epic Quest: Zer0-to-Her0 CMStyle quests
  Discover how one nerd transformed from zero to hero by building an AI-powered open source CMS using VS Code and Jekyll. Join the epic journey!
• 404 Hunting: Binary Wards for Unbreakable Links quests
  Banish 404s in Jekyll with permalink magic, redirect runes, CI link guardians, and living resource endpoints powered by GitHub.
• Nerd Font Enchantment: Terminal Icon Mastery quests
  Install Nerd Fonts on macOS, Linux, and Windows, then configure your terminal and VS Code so icons, glyphs, and Oh-My-Zsh themes render correctly.
• Terminal Enchantment: Oh-My-Zsh Mastery quests
  Install Oh-My-Zsh, then customize your terminal with themes, plugins, and VS Code integration to supercharge your command-line development workflow.
• Docker Containerization Mastery: Level 0101 (5) Quest quests
  Master Docker containerization to build, deploy, and manage applications in isolated, portable environments with practical hands-on projects
• The Diagrammatic Enchantment: Jekyll-Mermaid Integration quests
  Master diagrammatic magic by integrating Mermaid.js into any Jekyll site, with conditional loading, dark mode, and responsive interactive diagrams.
• The Knowledge Vault: Building an Automated Documentation Hub quests
  Build a centralized documentation system that aggregates and organizes knowledge from multiple GitHub repositories using automation
• Recursive Realms: Testing Infinite Loops with AI quests
  Master Python recursion, base cases, and call stacks while building pytest suites, preventing stack overflows, and applying recursive thinking to AI design.
• Forging the Stats Portal: Data Analytics Quest quests
  Build a Jekyll stats portal that auto-generates site metrics and displays posts, words, categories, and tags with Bootstrap-powered visualizations.
• Stack Attack Analysis: IT-Journey quests
  Dissect the IT-Journey platform stack: Jekyll and Ruby frontend, Python automation, Docker, GitHub Actions CI/CD, and AI-powered content analysis.
• Stack Attack: AI-Built Django + React Enterprise ERP quests
  Use AI agents to research, design, and scaffold a production-grade open-source ERP with a Django REST backend and a React TypeScript frontend.
• Technology Stack Analysis: Barodybroject quests
  Comprehensive analysis of the Barodybroject Django-based parody news generator with OpenAI integration and Azure Container Apps deployment
• Kaizen Quest: Continuous Improvement Alchemy quests
  Master Kaizen for software teams: run PDCA cycles, eliminate the seven wastes, map value streams, track DORA metrics, and build a blameless culture.
• Forging the Prompt Crystal: Master AI Communication quests
  Master prompt engineering to craft optimal AI instructions. Learn systematic design, iterative refinement, and structured patterns for language models.
• Building & Testing the Git Init Shell Script quests
  Hands-on quest to build, extend, and test `git_init.sh` — an interactive and headless repo initializer with programmatic scaffolding.
• The GitHub Pages Portal: Forging Your Digital Realm quests
  Master the art of deploying static websites using GitHub Pages, transforming your code into live web experiences with no server required.
• Hidden Gem Quest: Publish AI Chats on GitHub Pages quests
  Wield GitHub Pages and Jekyll to forge repositories into live websites, then capture and immortalize AI conversations as published posts with VS Code.
• Terminal Artificer: Forging the Glass Interface quests
  Master the art of crafting beautiful, interactive frontends for your shell scripts using Gum, transforming raw command-line magic into elegant tools.
• Forging the Prompt Crystal: VS Code Copilot Mastery Quest quests
  Master prompt engineering for VS Code Copilot: structured RCTF patterns, few-shot and Chain-of-Thought prompting, and PDCA-driven refinement.
• The PRD Codex: Master Product Reality Distillation quests
  Master the ancient art of transforming scattered signals into living Product Requirements Documents using automated tooling and CI/CD integration
• Git Basics: Version Control Introduction quests
  Learn Git fundamentals including repositories, commits, branches, and basic workflow for tracking code changes and collaborating with developers.
• Markdown Mastery: Content Formatting Fundamentals quests
  Master Markdown syntax for creating rich documentation, blog posts, and technical content with proper formatting, links, images, and code blocks.
• Terminal Fundamentals: Command Line Navigation Quest quests
  Master essential command line skills including navigation, file management, and basic shell commands across macOS, Linux, and Windows terminals.
• Advanced Markdown: Tables, Footnotes & Kramdown quests
  Go beyond basic Markdown with tables, footnotes, fenced code, callouts, Kramdown attributes, and YAML frontmatter that builds Jekyll pages.
• Analytics Integration: Privacy-Aware Web Measurement quests
  Add privacy-aware analytics to your site: compare GA4 and lightweight alternatives, track custom events, respect consent, and read dashboards.
• Bootstrap Framework: Build Responsive Sites Fast quests
  Master Bootstrap 5: use the 12-column grid, prebuilt components, and utility classes to build mobile-first responsive sites without custom CSS.
• CSS Styling Basics: Selectors, the Box Model & Layout quests
  Master CSS fundamentals: selectors, the box model, flexbox and grid, responsive media queries, and custom properties through hands-on examples.
• Git Workflow Mastery: Branches, Merging & Team Collaboration quests
  Master a clean Git workflow: feature branches, focused commits, pull requests, merge vs rebase, and calmly resolving conflicts to collaborate confidently.
• GitHub Pages Basics: Host Your Jekyll Site for Free quests
  Publish a Jekyll site to the world with GitHub Pages: repository setup, the _config.yml url and baseurl, deployment, and wiring a custom domain.
• JavaScript Fundamentals: Variables, Functions & the DOM quests
  Learn JavaScript from zero: variables and types, functions, arrays and objects, DOM manipulation, events, and fetch to make web pages interactive.
• Jekyll Fundamentals: Build Static Sites with Ruby quests
  Master Jekyll static site generation: install Ruby and Jekyll, learn the project structure and collections, then build and serve a fast, secure site.
• Jekyll Plugins: Extend Your Static Site Safely quests
  Add Jekyll plugins safely: discover GitHub-Pages safe gems, configure SEO and sitemap extensions, then write your own custom generator or filter.
• Liquid Templating: Dynamic Content for Jekyll Sites quests
  Master Liquid, the templating language behind Jekyll: variables, filters, loops, conditionals, includes, and layouts that render dynamic pages at build time.
• SEO Optimization: Meta Tags, Sitemaps & Structured Data quests
  Master technical SEO for Jekyll: write meta tags, generate sitemaps and robots.txt, add JSON-LD structured data, and automate it all with jekyll-seo-tag.
• YAML Configuration: Site Settings Mastery quests
  Master YAML for Jekyll: write front matter, configure _config.yml, build _data files, and dodge the indentation, quoting, and type pitfalls beginners hit.
• Docker Container Fundamentals: Images to Registries quests
  Master Docker container fundamentals: images versus containers, writing a Dockerfile, build and run workflows, image layers and caching, and registries.
• Docker Compose Orchestration: Multi-Container Apps quests
  Master Docker Compose to orchestrate multi-container apps. Define services, networks, volumes, depends_on, and environment variables in one YAML file.
• Artifact Management: Versioned, Signed Build Output quests
  Manage build artifacts in CI/CD. Learn registries, semantic versioning, immutable tags, and supply-chain provenance with SBOMs and signed builds.
• CD Fundamentals: The Build-Test-Deploy Pipeline quests
  Master CI/CD fundamentals: the build-test-deploy flow, how continuous integration, delivery, and deployment differ, pipeline stages, and fast feedback loops.
• Deployment Pipelines: Production Release Automation quests
  Build robust deployment pipelines for production releases. Learn environments, promotion, blue-green and canary deployments, approvals, and automated rollbacks.
• Environment Management: Dev, Staging, and Prod Parity quests
  Manage multiple deployment environments. Achieve dev/staging/prod parity, configure per-environment settings, and promote infrastructure changes safely.
• GitHub Actions Basics: Workflow Automation for Modern DevOps quests
  Build GitHub Actions workflows from scratch: master jobs, steps, triggers, runners, secrets, and matrix builds to automate your testing and deployment.
• Secrets Management: Secure CI Credentials quests
  Handle CI secrets securely. Learn OIDC versus long-lived credentials, vault systems, least privilege, scoping, and rotation for pipelines and applications.
• CD Test Gates quests
  Integrate automated testing into your CI/CD pipeline. Learn unit, integration, and end-to-end test stages, coverage gating, and taming flaky tests.
• CD quests
  Make CI/CD pipelines fast and cheap. Learn dependency caching, parallelism, matrix builds, concurrency control, and reusable workflows.
• Backup and Recovery: Data Protection for Databases quests
  Guard against data loss with logical and physical backups, point-in-time recovery, RTO/RPO targets, and the restore drills that prove a backup actually works.
• Connection Pooling: Efficient Database Resource Management quests
  Understand the connection lifecycle, size a pool correctly, deploy PgBouncer, and hunt down the leaks that exhaust a healthy PostgreSQL database.
• Data Modeling: Schema Design and Database Relationships quests
  Turn fuzzy requirements into solid database schemas using entity-relationship modeling, normalization to 3NF, and one-to-many and many-to-many relationships.
• Database Fundamentals: The Relational Model and ACID quests
  Master the relational model behind modern databases - tables, keys, ACID transactions, and normalization - then prove it with hands-on PostgreSQL SQL.
• Database Migrations: Schema Evolution and Version Control quests
  Evolve a live database safely: write versioned up/down migrations, use Flyway, Liquibase, or Alembic, and ship zero-downtime schema changes.
• Database Security: Access Control and Data Encryption quests
  Defend the Data Keep with least-privilege grants, parameterized queries that stop SQL injection, encryption at rest and in transit, and audit logging.
• Query Optimization: Tuning Fast Database Queries quests
  Read EXPLAIN plans, pick the right indexes, slay the N+1 query, and rewrite slow SQL to run in milliseconds on a real PostgreSQL database.
• SQL Mastery: Query Language Proficiency quests
  Wield SQL like a battle-mage against a real PostgreSQL database: SELECT, JOIN, GROUP BY, subqueries, views, indexes, and transactions turning data into answers.
• API Authentication: Keys, Tokens, OAuth2, and JWT quests
  Master API authentication including API keys, sessions versus tokens, JSON Web Tokens, OAuth2 flows, and scopes so you can secure and consume protected APIs.
• API Documentation: OpenAPI, Swagger, and Contract-First quests
  Master API documentation using OpenAPI and Swagger: write a contract-first spec, add request and response examples, and render live docs.
• API Fundamentals: HTTP, Requests, and JSON quests
  Master the fundamentals of web APIs including HTTP methods, status codes, request/response anatomy, headers, and JSON so you can call and reason about any API.
• API Versioning: URI, Headers, and Backward Compatibility quests
  Master API versioning strategies including URI versus header versioning, backward compatibility, breaking versus non-breaking changes, and graceful deprecation.
• Error Handling: Status Codes, Problem Details, and Retries quests
  Master API error handling including status code selection, the problem+json format, validation errors, idempotency keys, and safe retry strategies with backoff.
• Rate Limiting: Token Buckets, 429s, and Quotas quests
  Master API rate limiting with token and leaky bucket algorithms, the 429 response, rate-limit headers, quotas, and client-side backoff throttling.
• REST Principles: Resources, Statelessness, and Maturity quests
  Master REST constraints: resources, statelessness, the uniform interface, HATEOAS, and the Richardson Maturity Model to design clean web APIs.
• AWS Essentials: Core Services and Architecture quests
  Get hands-on with the core AWS services - IAM, EC2, S3, and VPC networking - plus the AWS CLI and the Well-Architected Framework pillars.
• Cloud Computing Fundamentals: IaaS, PaaS, and SaaS Explained quests
  Learn the IaaS, PaaS, and SaaS service models, regions and availability zones, the shared responsibility model, and the core services every cloud offers.
• Infrastructure as Code: Terraform Fundamentals and State quests
  Provision cloud infrastructure declaratively with Terraform: providers and resources, the plan/apply lifecycle, state files, variables, and idempotency.
• Kubernetes ConfigMaps and Secrets: The Vault quests
  Manage Kubernetes config with ConfigMaps and Secrets: inject settings via env vars and volume mounts, and guard credentials beyond base64.
• Kubernetes Pods and Workloads: Deployments and StatefulSets quests
  Master Kubernetes workloads: run Pods via ReplicaSets and Deployments, scale and roll out updates, roll back, and choose StatefulSets or DaemonSets.
• Kubernetes Services and Networking: Ingress and DNS quests
  Master Kubernetes networking with Services, Ingress, and cluster DNS, choosing between ClusterIP, NodePort, and LoadBalancer to expose workloads.
• Kubernetes Fundamentals: Container Orchestration Essentials quests
  Master Kubernetes basics: cluster architecture, the control plane and worker nodes, kubectl, and the declarative object model that orchestrates containers.
• Alerting Systems: Alertmanager, Routing, On-Call & Runbooks quests
  Forge production alerting with Prometheus rules and Alertmanager: routing, grouping, silencing, inhibition, on-call escalation, and runbooks.
• Distributed Tracing with Jaeger & OpenTelemetry quests
  Instrument a Python service with OpenTelemetry, emit spans to Jaeger, propagate trace context, and debug latency across your microservices.
• ELK Stack: Elasticsearch, Logstash & Kibana Logs quests
  Deploy the ELK stack for centralized logging: Elasticsearch indexing, Logstash and Beats pipelines, and Kibana dashboards for distributed systems.
• Monitoring Fundamentals: Metrics, Logs, and Traces quests
  Master the three pillars of observability—metrics, logs, and traces—plus SLI/SLO/SLA, the RED and USE methods, and fighting alert fatigue.
• Prometheus & Grafana: Metrics Collection and Visualization quests
  Master the Prometheus data model, write PromQL queries, run exporters and scrape targets, and build Grafana dashboards from raw time series.
• Compliance Standards: SOC 2, ISO 27001, GDPR, and PCI-DSS quests
  Navigate the major security compliance frameworks - SOC 2, ISO 27001, GDPR, and PCI-DSS - learning controls mapping, audit evidence, and audit prep.
• Penetration Testing: Tools and Ethical Hacking Methodologies quests
  Learn authorized, ethical penetration testing: defining scope, reconnaissance, nmap scanning, web testing with Burp Suite and ZAP, and clear reporting.
• Secure Coding: Preventing the OWASP Top 10 quests
  Forge code that defeats the OWASP Top 10: master input validation, injection prevention, authentication, secrets handling, and dependency security.
• Security Fundamentals: CIA Triad and Defense in Depth quests
  Master information security fundamentals including the CIA triad, the OWASP Top 10, defense in depth, secure-by-design thinking, and practical risk management.
• Threat Modeling: STRIDE Framework and Attack Trees Analysis quests
  Master threat modeling with STRIDE, data-flow diagrams, trust boundaries, and attack trees to find security flaws systematically before attackers do.
• Apache Spark Mastery: Big Data with PySpark quests
  Master Apache Spark for distributed data: RDDs, DataFrames, transformations vs actions, lazy evaluation, partitions, shuffles, and tuning with PySpark.
• Data Quality Engineering: Validation & Monitoring quests
  Build data quality into your pipelines: master the six quality dimensions, profiling, validation suites, data contracts, anomaly detection, and lineage.
• Data Warehousing: Build a Dimensional Star Schema in SQL quests
  Build the Analytical Citadel: model OLTP vs OLAP, design star and snowflake schemas, implement slowly changing dimensions, and explore columnar storage.
• ETL Pipeline Design: Scalable Python Data Pipelines quests
  Build production ETL pipelines in Python: ETL vs ELT, extraction and loading, idempotent upserts, incremental loads, and Airflow orchestration.
• Stream Processing: Real-Time Data with Apache Kafka & Flink quests
  Build real-time streaming pipelines with Apache Kafka. Master batch versus stream, event-time windowing, watermarks for late data, and exactly-once delivery.
• AI Ethics: Bias Detection, Fairness & Governance quests
  Build responsible AI: measure bias and fairness, explain model decisions, protect privacy, and govern high-risk systems under the EU AI Act and NIST AI RMF.
• Computer Vision Mastery: CNNs and Transfer Learning quests
  Build computer vision models in PyTorch: learn convolutions, train CNNs for image classification, and fine-tune pretrained models with transfer learning.
• Deep Learning Frameworks: PyTorch vs TensorFlow quests
  Compare PyTorch and TensorFlow hands-on: master tensors, autograd, model building, the training loop, and GPU acceleration for production deep learning.
• Machine Learning Fundamentals with Scikit-Learn quests
  Master supervised and unsupervised learning in Python: split data correctly, fight overfitting, and evaluate scikit-learn models with honest metrics.
• CD Pipelines for ML in Production quests
  Take ML models from notebook to production with MLflow tracking, a model registry, FastAPI serving, drift monitoring, and CI/CD retraining pipelines.
• Natural Language Processing: Transformers & LLMs quests
  Build NLP apps in Python with Hugging Face: master tokenization, embeddings, and the attention mechanism behind modern large language models.
• Neural Networks Deep Dive: Build One From Scratch quests
  Build a neural network from scratch, then in PyTorch, mastering neurons, layers, activations, forward propagation, backpropagation, and gradient descent.
• Python for Data Science: NumPy, Pandas & Matplotlib quests
  Forge the Data Artisan's Toolkit: master NumPy vectorization, Pandas DataFrames, exploratory analysis, and Matplotlib charts, then train a scikit-learn model.
• API Gateway Patterns: The Single Front Door quests
  Master API gateway patterns - routing, authentication, rate limiting, and response aggregation - plus the Backend-for-Frontend pattern for tailored clients.
• Software Design Patterns: Gang of Four and Modern Patterns quests
  Implement Factory, Strategy, Observer, Adapter, and Decorator, master the five SOLID principles, and refactor brittle conditionals into clean patterns.
• Domain-Driven Design: Modeling the Business in Code quests
  Master DDD: ubiquitous language, entities and value objects, aggregates, and bounded contexts so your code models the business it serves.
• Sub, Event Sourcing, and CQRS quests
  Learn event-driven architecture: events as facts, pub/sub messaging, event sourcing, CQRS, and the eventual consistency that decouples systems.
• Microservices Architecture: Decomposing the Monolith quests
  Decide when to split a monolith, decompose by bounded context, and navigate inter-service communication, data ownership, and distributed failure modes.
• Scaling Strategies: Horizontal Growth, Caching, and CAP quests
  Master scaling: vertical vs. horizontal growth, load balancing, caching layers, database replication and sharding, and the CAP theorem.
• System Design Interviews: A Framework for the Whiteboard quests
  Learn a repeatable system design interview framework - clarify requirements, estimate capacity, apply RESHADED, and articulate trade-offs out loud.
• Architecture Reviews: ADRs and Trade-off Facilitation quests
  Run effective architecture and design reviews. Learn to facilitate trade-off discussions, write Architecture Decision Records, and lead reviews without ego.
• Building Technical Communities: Govern and Include quests
  Build thriving technical communities. Learn the membership lifecycle, running events, governance and moderation, and designing for inclusion and belonging.
• Career Advancement: IC vs Management and Leveling quests
  Advance your engineering career deliberately. Learn the IC vs management fork, how leveling rubrics work, building a technical brand, and negotiating offers.
• Innovation and R&D: Experimentation and Technical Bets quests
  Drive engineering innovation. Learn structured experimentation, the three-horizons portfolio model, and how to manage risky technical bets responsibly.
• Mentorship Programs: Growing Engineering Talent quests
  Build effective engineering mentorship: learn mentoring models, feedback that lands, growth frameworks, and how mentoring differs from sponsorship.
• Open Source Contribution: Maintaining and Licensing quests
  Contribute to and maintain open source. Learn the contribution workflow, community norms, reviewing and triaging issues, and the basics of software licensing.
• Tech Speaking and Writing: RFCs, Docs, and Talks quests
  Communicate technical ideas with impact. Learn technical writing, design docs and RFCs, structuring a conference talk, and persuading an audience to act.
• Technical Leadership: Leading Without a Crown quests
  Lead engineers without a title: set a technical vision, frame and close decisions under uncertainty, and delegate work with clear ownership.
• Jekyll Quest Tracking: Building Dynamic Collection Layouts quests
  Build a Jekyll quest-tracking interface with dynamic filtering, collection stats, and level-aware displays using Liquid templating and frontmatter.
• Hello Cloud: First Steps into the Sky Realm quests
  Claim your first foothold in the Sky Realm: create a secured cloud account with MFA, wield a cloud CLI, provision a resource, then banish it to avoid costs.
• Hello macOS: Setting Up the Apple Kingdom quests
  Transform your Mac into a professional dev workstation: install Xcode Command Line Tools and Homebrew, configure iTerm2, and verify Git and SSH.
• Forge Your Character: Crafting Your Contributor Identity quests
  Create your contributor character profile with RPG-style stats, badges, and class identity — powered by your git history
• Avatar Forge: Crafting Your Digital Portrait quests
  Replace your default identicon by sourcing or creating a custom avatar, hosting the image, and wiring it into your contributor data file to brand your profile.
• Badge Collector: Showcasing Your Achievements quests
  Discover how achievement badges are auto-earned from your contributions, then pin your proudest three to the Featured section of your profile.
• Contribution Calendar: Mapping Your Journey Through Time quests
  Build a GitHub-style contribution heatmap for your character profile, rendering 52 weeks of activity data with CSS Grid and Jekyll Liquid templates.
• Stats Dashboard: Enhancing Your Data Visualization quests
  Upgrade your character sheet's stats panel with language bars, progress rings, and contribution charts built in pure HTML, CSS, and Liquid.
• Profile Themes: Unleashing the Style Sorcerer quests
  Craft custom CSS theme variants for the contributor profile system using custom properties, light and dark modes, and WCAG AA accessible color contrast.
• Mastering Version Control Workflows: The Grand Merge Ritual quests
  Master advanced Git workflows: semantic versioning, branch strategies, CI/CD automation, and pull request orchestration with real open-source examples.
• The Artisan's Forge: Refactoring Jekyll Theme Components quests
  Learn to refactor inline Jekyll theme elements into modular, config-driven components — using a real-world nanobar and footer case study.
• The Three Sigils: Plan, Reason, Act quests
  Configure a GitHub Copilot coding agent to produce a structured plan, define its JSON schema, and gate every action behind human approval.
• Initiation Rites: Embedding Agents in the SDLC quests
  Integrate AI agents into the SDLC: define their inputs, outputs, and success criteria, and learn the anti-patterns that sink autonomous workflows.
• The MCP Conclave: Mastering Model Context Protocol Servers quests
  Configure and operate Model Context Protocol servers so GitHub Copilot agents can reach external tools and APIs securely, with observability built in.
• The All-Seeing Eye: Observability for AI Agents quests
  Instrument GitHub Copilot agents with execution traces, inspectable artifacts, audit trails, and human review gates that catch drift without blocking runs.
• Forging the Agent's Arsenal: Tool Selection & Permissions quests
  Choose and configure the right tools for GitHub Copilot agents, then enforce least-privilege permissions so your agent touches only what it needs.
• Bind the Agent to the Realm: Dev Environment Integration quests
  Configure AGENTS.md, a dev container, and secrets so a GitHub Copilot agent runs predictably and identically in Codespaces and on your machine.
• Vaults of Recollection: Agent Memory Strategies quests
  Design ephemeral, session, and persistent memory for GitHub Copilot agents using artifacts, issues, and repo files to keep context across interactions.
• The Shield of Retries: Safe Execution and Error Handling quests
  Build resilient GitHub Copilot agents with retry logic, timeouts, fallback strategies, and graceful error reporting that survive tool failures and API errors.
• The Necromancer's Inquest: Agent Failure Root Cause Analysis quests
  Read GitHub Actions logs, artifacts, and execution traces, then apply a 5-Why RCA framework to find why an agent failed and prevent it recurring.
• Crossing the Tool Planes: State Continuity Across Tools quests
  Keep an agent's state and context intact when tasks cross GitHub surfaces — issues, PRs, Actions runs, and Codespaces each hold fragments to weave together.
• Anchoring the Drifting Agent: Stop Context Drift quests
  Detect and prevent context drift in long-running GitHub Copilot agent sessions with state checkpointing, drift signals, and recovery procedures.
• The Oracle's Rubric: Agent Success Signals quests
  Define machine-verifiable acceptance criteria for agent tasks, map them to GitHub signals like Actions checks and PR states, then automate completion detection.
• Reforging the Agent's Mind: Tuning Behavior by Instruction quests
  Tune your GitHub Copilot agent by analysing failure patterns, iterating on copilot-instructions.md and AGENTS.md, and measuring each change's impact.
• When Familiars Fall: Multi-Agent Failure Recovery quests
  Build resilient multi-agent systems on GitHub: classify and detect sub-agent failures, retry with backoff, re-delegate, and preserve partial progress.
• The Scribe's Codex: Observability in Multi-Agent Systems quests
  Add observability to multi-agent GitHub workflows by correlating traces across agents, detecting inter-agent failures, and building a unified audit log.
• The Council of Many: Multi-Agent Orchestration Patterns quests
  Build multi-agent systems on GitHub: design fan-out, sequential chain, and event-driven orchestrators that dispatch sub-agent jobs and aggregate their results.
• The Autonomy Scales: Mapping Agent Autonomy Levels quests
  Map GitHub Copilot agents across a five-level autonomy spectrum, classify your task types by risk, and configure the GitHub controls that govern each level.
• Trial of the Agentic Codex: The Grand Capstone quests
  Face the six-domain grand trial: build a complete agentic AI system on GitHub, prove competency across all GH-600 domains, and earn Codex Master.
• The Warden's Pact: Guardrails and Human-in-the-Loop Patterns quests
  Build responsible agentic AI guardrails with GitHub-native tools: boundary enforcement, human approval gates, escalation protocols, and audit trails.
• The Agent Pantheon: Multi-Agent Lifecycle Management quests
  Run the full lifecycle of a GitHub-native multi-agent system: build a registry, monitor agent health, and provision, version, and retire agents safely.
• Bashcrawl Agent Mode: AI Automation and Contribution quests
  Explore Bashcrawl's Agent Mode for AI playtesting, screenshot capture, batch automation, and upstream contribution. The capstone quest for dungeon masters.
• Bashcrawl Armoury: File Permissions and Script Execution quests
  Learn chmod, file permissions, and script execution in Bashcrawl's Armoury. Brew a health potion and wield a sword for your first combat encounter.
• Bashcrawl Cellar: File Types, Aliases, and Emerald Amulet quests
  Master file types with ls -F, create alias shortcuts, and discover the emerald amulet in Bashcrawl's Cellar. Completing this chamber unlocks four deeper areas.
• Bashcrawl Chamber: Bash Arithmetic and the Statue Boss quests
  Defeat Bashcrawl's Statue Boss by solving arithmetic with let, expr, and $(( )). Mastering Bash math is the only weapon that can defeat this stone guardian.
• Bashcrawl Entrance: Your First Terminal Commands quests
  Learn pwd, ls, cd, and cat by exploring the Bashcrawl entrance — read the first scroll, get a hint from Merlin, and collect your brass key to proceed.
• Bashcrawl Hidden Chapel: Hidden Files and Man Pages quests
  Uncover the Hidden Chapel with ls -a, explore the courtyard, aviary, hall, and graveyard. Use man pages and --help to defeat the monster and claim the tome.
• Bashcrawl Rift: Pipes, Redirection, and the Final Boss quests
  Conquer Bashcrawl's final gauntlet — the Rift — by mastering pipes, &&, ||, and output redirection. Defeat the pit boss and satellite boss to complete.
• Bashcrawl Scrap Heap: Symbolic Links and Portal Creation quests
  Learn symbolic links in Bashcrawl's Scrap Heap using ln -s, readlink, and ls -l. Create portal symlinks that warp you instantly to distant dungeon corners.
• Bashcrawl Vault: Environment Variables and the Goblet Puzzle quests
  Master environment variables in Bashcrawl's Vault using export, echo $VAR, and env. Solve the goblet puzzle in the stronghold and survive a ghost encounter.
• Bashcrawl Workshop: File Management Fundamentals quests
  Practice file management in the Workshop: mkdir, touch, rm, cp, mv, and I/O redirection. Build rooms, write scrolls, and clear debris to advance.
• The Summoning: Raise the Site and Give It a Voice quests
  Raise a Jekyll site on a remote theme and GitHub Pages, encode a machine-readable brand and voice, and teach it to write a shareable dispatch at the end of e...
• The Proving Grounds: The Repo's First CI Gate quests
  Build the repository's first CI: a deterministic verification harness with a frozen findings contract, link-checking, and front-matter linting that turns "is...
• The Cartographer: File Platform Bugs Upstream quests
  Keep the product thin: tell a product bug from a platform bug, and file the platform one upstream as a maintainer-ready issue instead of patching around it i...
• The War Machine: Dispatch, Leasing, and a Fifty-Case Simulation quests
  Stand up the autopilot proper — OODA dispatch, serverless git-ref CAS leasing, RICE triage, tiered pipelines, and a fifty-case end-to-end simulation that pro...
• The Sigils of Trust: Auth, Secrets, and the Kill Switch quests
  Wire authentication and secrets so the robot can act but never escalate: OAuth versus API keys, a least-privilege bot PAT with no admin scope, and a *_ENABLE...
• The Content Forge: Autonomous Generation That Refuses to Lie quests
  Teach the site to write its own scrolls from a backlog — and to refuse to publish what it cannot verify. The Prime Directive, plus one-writer-per-collection ...
• The Editor's Eye: A Reviewer, and the Dragon It Becomes quests
  Add a reviewer that improves each draft in place, then fight the boss: the synchronize self-retrigger loop that reviews its own edits forever, and the loop-b...
• The Bard Forge: The Quest That Writes Quests quests
  Close the autonomy loop: a published retrospective triggers a read-only agent that mines merged-branch metadata and proposes a gamified quest to a separate r...
• The Named Familiars: Agents, Skills, and a Self-Review Loop quests
  Give every automation role a named agent — persona, tools, and hard rules — distinct from the skills that hold the procedure, and add a routine that reviews ...
• The Chronicle: A SessionEnd Hook That Remembers quests
  Make the castle remember: a SessionEnd hook that writes down what each session cost, a queue and a durable ledger, and the to_yaml round-trip hazard that sil...
• Epic Quest: The Self-Operating Website quests
  Forge a Jekyll site that runs itself — a robot drafts content, files its own bugs, opens and reviews pull requests, and journals every session, while a human...
• Initiation Rites: Agents in the SDLC quests
  Embed GitHub Copilot agents into the software lifecycle with bounded roles, plan-then-act gates, and observable traces — GH-600 Domain 1 of The Agentic Codex.
• Forging the Arsenal: Tool Use & Environment quests
  Equip GitHub Copilot agents with the right tools, wire MCP servers, scope least-privilege permissions, and bind agents to a CI environment — GH-600 Domain 2.
• Vaults of Recollection: Memory & State quests
  Master the three tiers of agent memory, persist state across GitHub Actions runs, and detect context drift before it corrupts an agent. GH-600 Domain 3.
• The Oracle Rubric: Evaluation & Tuning quests
  Define machine-verifiable success criteria, read GitHub signals to grade agent runs, run root-cause analysis on failures, and tune behaviour by instruction.
• The Council of Many: Multi-Agent Coordination quests
  Orchestrate a council of agents on GitHub Actions: fan-out and chain patterns, correlation-ID tracing, failure recovery, and lifecycle. GH-600 Domain 5.
• The Warden Pact: Guardrails & Accountability quests
  GH-600 Domain 6: classify agent actions by risk, set autonomy levels, enforce least-privilege guardrails, gate humans in the loop, and build an audit trail.
• Epic Quest: The Ouroboros Loop quests
  Build an autonomous test→fix→merge loop that perfects its own content: Claude Code golems, CI stage gates, sealed evidence, mana budgets, rotating windows, c...
• Forge Your Own Dev Server: Bare Metal to Watchtower quests
  Turn a bare Debian box into a development server: packages, users, firewall, language toolchains, a container service stack, and a live monitoring dashboard.
• The Dig Site: Unearth the Relic and Name What You Do Not Know quests
  Compile and run a 1997 COBOL aging program on your own machine, ask an AI familiar to read it, and learn the raiser's first discipline: every reading is a hy...
• The Gauntlet of Trials: Pin the Relic Before You Touch It quests
  Write characterization trials that pin what a legacy program actually does, capture golden masters, bind the relic in a container so it runs identically anyw...
• The Strata: Read the Copybook, Then Let the Data Testify quests
  Decode a COBOL copybook into a data dictionary, profile the fixed-width file field by field until the two tells surface, and date every layer of the relic's ...
• The Strangler Fig: Put a Modern Gate in Front of the Relic quests
  Grow a modern HTTP gate around the COBOL relic: it answers from the relic by default, runs the reconciled port in shadow and logs every mismatch, cuts over b...
• The Rosetta Ledger: Translate the Relic and Prove It Ties Out quests
  Have a familiar port the COBOL relic to Python, then build the reconciliation that judges it: the first port is fluent and wrong three ways, and only a ledge...
• Write for the Archaeologist: Leave the Lore Where the Next One Digs quests
  Close the campaign by making the revived system legible to whoever comes next: a map, a runbook, decision records for every choice you made, a roadmap that s...
• The Elders: Recover the Reasons Before They Retire quests
  Find the people and documents that remember why a relic works the way it does, run a knowledge-capture interview that asks for the why, and turn the answers ...
• Epic Quest: The Relic Raisers quests
  Learn to use today's AI familiars to read, test, translate, and revive the ancient systems a business still runs on: a seven-chapter campaign from a COBOL re...