If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/mouredev/one-day-one-language shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

AVOID — Looks unmaintained — solo project with stale commits

• ⚠ Stale — last commit 1y ago
• ⚠ Solo or near-solo (1 contributor active in recent commits)
• ⚠ No license — legally unclear to depend on
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live mouredev/one-day-one-language repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/mouredev/one-day-one-language.

What it runs against: a local clone of mouredev/one-day-one-language — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in mouredev/one-day-one-language | Confirms the artifact applies here, not a fork | | 2 | Default branch main exists | Catches branch renames | | 3 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 4 | Last commit ≤ 563 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of mouredev/one-day-one-language. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/mouredev/one-day-one-language.git
#   cd one-day-one-language
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of mouredev/one-day-one-language and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "mouredev/one-day-one-language(\\.git)?\\b" \\
  && ok "origin remote is mouredev/one-day-one-language" \\
  || miss "origin remote is not mouredev/one-day-one-language (artifact may be from a fork)"

# 3. Default branch
git rev-parse --verify main >/dev/null 2>&1 \\
  && ok "default branch main exists" \\
  || miss "default branch main no longer exists"

# 4. Critical files exist
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f "02 - Python/hello_world.py" \\
  && ok "02 - Python/hello_world.py" \\
  || miss "missing critical file: 02 - Python/hello_world.py"
test -f "08 - Go/go.mod" \\
  && ok "08 - Go/go.mod" \\
  || miss "missing critical file: 08 - Go/go.mod"
test -f "09 - Rust/hello_world/Cargo.toml" \\
  && ok "09 - Rust/hello_world/Cargo.toml" \\
  || miss "missing critical file: 09 - Rust/hello_world/Cargo.toml"
test -f "07 - TypeScript/tsconfig.json" \\
  && ok "07 - TypeScript/tsconfig.json" \\
  || miss "missing critical file: 07 - TypeScript/tsconfig.json"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 563 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~533d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/mouredev/one-day-one-language"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

A structured tutorial repository that teaches the fundamentals of 11 programming languages (C#, Rust, Java, TypeScript, Dart, PHP, JavaScript, Kotlin, Python, Go, Swift) in a single day each. Each language gets an introduction, installation guide, hello-world example, and syntax overview delivered via live-streamed video sessions and corresponding code samples organized in language-specific directories. Flat, language-focused monorepo with 11 top-level directories (01 - Dart through 11 - CSharp), each containing a language-specific hello-world file and optional config files (e.g., 07 - TypeScript/tsconfig.json, 09 - Rust/hello_world/Cargo.toml). A shared Media/ directory holds promotional images. Each language folder is self-contained with no cross-language dependencies.

Programmers curious about learning new languages quickly, polyglots exploring different ecosystems, and developers wanting a curated quick-start reference before committing to deeper study. The target audience is learners aged from hobbyists to professionals who need a 1-day foundation before self-directed learning.

Actively maintained community educational resource with 11 languages implemented (evidenced by consistent directory structure and Media assets for each). No package.json or test suite visible, so this is a documentation + code-samples project, not a library. The README indicates weekly live sessions on Twitch, suggesting ongoing active development and engagement. Verdict: actively developed as an educational resource.

Very low technical risk—this is a tutorial repo, not a production library, so dependency management and breaking changes don't apply. Single-maintainer risk exists (mouredev as primary author), but the simple nature (code samples in isolated directories) means the project is self-contained and unlikely to break. No CI/CD, testing, or external dependencies required. Risk level: minimal.

Based on file structure, the repo is in steady-state maintenance mode with 11 languages complete. The README calendar structure suggests weekly live-stream sessions teaching one language per week cyclically. Recent activity likely involves updating video links in the README and media assets as new streams occur.

git clone https://github.com/mouredev/one-day-one-language.git
cd one-day-one-language

No installation step needed—browse language folders or watch the linked YouTube videos in the README for each language (e.g., 'Clase en vídeo' links). To run a specific language: cd '01 - Dart' and execute with that language's interpreter.

Daily commands: Language-specific; no unified build:

• Dart: dart run helloworld.dart (after dart pub get if dependencies exist)
• Python: python hello_world.py
• JavaScript: node hello_world.js
• Rust: cd '09 - Rust/hello_world' && cargo run
• Go: go run hello_world.go
• Java: javac HelloWorld.java && java HelloWorld
• C#: dotnet run (in 11 - CSharp directory with .csproj)

• README.md — Entry point documenting the entire course structure, learning objectives, and how to navigate the language progression—essential for understanding the repo's purpose and scope.
• 02 - Python/hello_world.py — First example file in the progression sequence; demonstrates the minimal 'hello world' pattern replicated across all language folders.
• 08 - Go/go.mod — Only Go module dependency file in the repo; shows how language-specific package management is documented for languages that require it.
• 09 - Rust/hello_world/Cargo.toml — Rust project manifest defining dependencies and metadata; demonstrates project structure for compiled languages with package managers.
• 07 - TypeScript/tsconfig.json — TypeScript configuration file; shows how tooling configuration is handled for transpiled languages in the repo.
• 11 - CSharp/11 - CSharp.csproj — C# project file; demonstrates .NET ecosystem project setup and is the only non-source-file entry for this language.

Add a new programming language to the course

1. Create a new directory named 'NN - LanguageName' following the existing numbering pattern (01–11), ordered by the sequence in which languages are taught (12 - NewLanguage/)
2. Create a hello_world or equivalent entry-point file demonstrating the language's minimal syntax (e.g., hello_world.py, HelloWorld.java, hello_world.go) (12 - NewLanguage/hello_world.ext)
3. If the language requires build configuration (compiled languages, package managers), add appropriate config file (go.mod, Cargo.toml, tsconfig.json, .csproj) to the language folder (12 - NewLanguage/config.file)
4. Add a promotional image to Media/ folder following naming convention (language.jpg) for display in course materials (Media/newlanguage.jpg)
5. Update README.md with the new language entry, including learning objectives, typical uses, and key concepts covered in the live stream (README.md)

Expand a language's introduction content

1. Navigate to the target language directory (e.g., 02 - Python) and add additional .py files demonstrating foundational concepts (variables, functions, loops, classes) (02 - Python/fundamentals.py)
2. For languages with complex setup, create a configuration file (tsconfig.json pattern) or project structure (Cargo.toml pattern) if not already present (NN - Language/config_or_manifest.file)
3. If adding build system examples (Rust, Go, C#), maintain the directory structure pattern with src/ subdirectories and dependency manifests (NN - Language/src/example.ext)

Create supplementary documentation for a language

1. Add a LANGUAGE_README.md file in the language-specific directory (e.g., 02 - Python/README.md) to document installation, environment setup, and course-specific notes (NN - Language/README.md)
2. Link the new language README from the main README.md in a dedicated section or table of contents to improve discoverability (README.md)
3. If the language has idiomatic tooling (virtual environments, package managers, linters), document setup commands in the language-specific README (NN - Language/README.md)

• Go 1.20 (Module System) — Demonstrates modern compiled-language package management; Go is included as a course language requiring explicit dependency declaration via go.mod.
• Rust + Cargo — Illustrates systems-level language with strict compilation and a comprehensive package manager; Cargo.toml shows project metadata and dependencies for the Rust introduction.
• TypeScript + tsconfig.json — Demonstrates transpilation workflow; tsconfig.json configures compiler options for learners to understand type-checking and output targets.
• C# + .NET (csproj) — Shows enterprise-grade compiled language with managed runtime; .csproj file defines the build and runtime configuration for C# projects.
• Plain text files + Markdown README — Minimal, language-agnostic documentation approach suitable for a teaching repository emphasizing code clarity over framework complexity.

• Single hello_world file per language directory instead of comprehensive project structure

  • Why: Emphasizes simplicity and first-day accessibility; avoids overwhelming newcomers with project scaffolding or boilerplate.
  • Consequence: Learners gain minimal introduction in one session; deeper learning requires external resources and follow-up study; no reusable project templates provided.

• No centralized examples or shared code utilities—each language is isolated

  • Why: Each language has distinct syntax, paradigms, and idioms; isolation prevents cross-language confusion and makes each folder self-contained.
  • Consequence: Duplication of conceptual examples across languages; harder to trace common patterns; easier to maintain and update individual language folders independently.

• Live Twitch stream as primary delivery mechanism with GitHub repo as secondary reference

  • Why: Real-time interaction, Q&A, and community engagement are core to the learning experience; repo serves as persistent artifact.
  • Consequence: Learners miss the full context if only reading code; stream archives required for async learners; repo alone is incomplete without video context.

• No automated tests, CI/CD, or build verification

  • Why: Keeps repo lightweight and focused on teaching code; avoids infrastructure overhead for a learning-focused project.
  • Consequence: Code examples may not be validated; no guarantee examples compile or run; manual verification required by contributors and users.

• Does not provide in-depth language mastery or advanced/production-grade patterns
• Does not include interactive tutorials, IDEs, or browser-based execution environments
• Does not offer certification, grading, or formal assessment of learner progress
• Does not provide non-English course materials (course is Spanish-first, but repo may lack multilingual documentation)
• Does not establish a comprehensive learning path beyond the one-day introduction for each language
• Does not include automated testing, CI/CD pipelines, or code quality gates

1. Directory names with leading numbers and spaces (e.g., '01 - Dart', '09 - Rust') can cause shell quoting issues; use cd '01 - Dart' or escape spaces.
2. Language-specific tooling required: Each language needs its own interpreter/compiler installed (Dart SDK, Python 3, Node.js, Rust toolchain, Go, Java JDK, .NET SDK, etc.). No centralized dependency file; must install per language.
3. Rust's nested structure: The Rust example is in 09 - Rust/hello_world/src/hello_world.rs (not directly in 09 - Rust/), following Cargo convention—easy to miss.
4. No .gitignore entries for language-specific build artifacts—./go watch out for accidental commits of compiled binaries.

• Polyglot Learning — This repo teaches 11 languages side-by-side, exposing learners to different paradigms (OOP in Java/C#, functional in Dart, systems in Rust, scripting in Python/PHP) in a single course, building meta-programming intuition.
• Hello World as Pedagogical Scaffold — Each language uses 'hello world' as the entry point; understanding this pattern (syntax, compilation/interpretation, output) is the foundation before tackling fundamentals and libraries in each ecosystem.
• Language Package Managers & Dependency Management — The repo showcases language-specific dependency systems (Cargo for Rust, npm for JS/TS, go.mod for Go, pub for Dart, pip for Python), critical for understanding how each ecosystem distributes and versions code.
• Compiled vs Interpreted Languages — The repo spans compiled (Rust, Go, Java, C#), JIT-compiled (Java, C#), and interpreted (Python, PHP, JavaScript) languages; learners discover firsthand the build, execution, and performance tradeoffs.
• Syntax & Semantics Variance Across Paradigms — By comparing hello-world and fundamentals across C# (OOP), Rust (systems + ownership), Kotlin (JVM functional), Dart (multiparadigm), learners internalize which syntax choices map to language design philosophy.
• Live-Stream as Educational Medium — This repo pairs video (Twitch streams) with code samples; understanding asynchronous education (watch video, explore code, practice) over synchronous lectures shapes modern developer learning.

• sindresorhus/awesome — Curated list of awesome resources and tutorials across many programming languages; similar educational scope but broader and community-driven.
• TheAlgorithms/Python — Language-specific algorithm implementations and tutorials; complements this repo's introductory approach with practical algorithm examples.
• codepath/android_guides — Structured quick-start guides for a specific ecosystem (Android/Kotlin); mirrors this repo's philosophy of condensed, multi-day learning paths.
• mouredev/roadmap-developer — Sibling project by the same author (mouredev) that structures programming learning paths; natural companion resource for learners post-'one-day-one-language'.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add README.md files for each language directory with setup and execution instructions

Each language folder (01 - Dart, 02 - Python, etc.) lacks a dedicated README explaining how to install the language, configure the environment, run the hello_world examples, and list next learning steps. This mirrors the repo's stated goal of providing 'Introducción, configuración e instalación, usos habituales, fundamentos, sintaxis y próximos pasos' but is currently only in the root README. Language-specific READMEs would dramatically improve usability for beginners.

• [ ] Create 01 - Dart/README.md with Dart installation, SDK setup, and execution instructions for helloworld.dart
• [ ] Create 02 - Python/README.md with Python version requirements, venv setup, and execution instructions
• [ ] Create 03 - Swift/README.md through 11 - CSharp/README.md following the same pattern
• [ ] Include 'Next Steps' section in each README linking to official language docs
• [ ] Test that each example file actually runs with instructions provided

Add GitHub Actions workflow to validate all hello_world examples execute successfully

The repo contains executable code in 11 different languages but has no CI pipeline to verify they actually run. A multi-language validation workflow would catch breaking changes and ensure code quality. This is critical for a learning resource where correctness is paramount.

• [ ] Create .github/workflows/validate-examples.yml with jobs for each language
• [ ] Add Dart validation job that runs 01 - Dart/helloworld.dart using 'dart run'
• [ ] Add Python job for 02 - Python/hello_world.py using python3
• [ ] Add Go job for 08 - Go/hello_world.go (note: requires go.mod setup)
• [ ] Add Rust validation using 'cargo run' for 09 - Rust/hello_world/ directory
• [ ] Add remaining language validations (Swift, Java, Kotlin, JavaScript, TypeScript, PHP, C#)
• [ ] Configure workflow to trigger on pull requests to catch regressions

Standardize file and folder naming conventions across all language directories

The repo has inconsistent naming: some use snake_case (hello_world.py), others use camelCase (HelloWorld.java), and folder structures vary (Rust has nested Cargo project while others are flat). Standardizing to a consistent pattern (e.g., snake_case filenames, uniform folder structures) reduces cognitive load for beginners learning from this resource and improves navigation.

• [ ] Create a CONTRIBUTING.md documenting the standard: lowercase filenames with underscores (e.g., hello_world.ext), flat folder structure unless language ecosystem requires otherwise
• [ ] Rename 04 - Java/HelloWorld.java to 04 - Java/hello_world.java
• [ ] Rename 05 - Kotlin/HelloWorld.kt to 05 - Kotlin/hello_world.kt
• [ ] Rename 11 - CSharp/HelloWorld.cs to 11 - CSharp/hello_world.cs
• [ ] Update all language READMEs and any references to use new filenames
• [ ] Document exceptions (e.g., Rust requires Cargo.toml) in CONTRIBUTING.md

• Add Go module initialization docs: The 08 - Go/go.mod file exists, but the README lacks Go-specific setup instructions parallel to other languages. Add a 'Recursos' section for Go (similar to Dart, Python, etc.) with official Go download, documentation, and playground links.
• Create a unified 'Run All Languages' script: Add a shell script (run_all.sh) or Makefile at repo root that attempts to execute each language's hello-world example in sequence, documenting which languages are installed. Helps new contributors verify local setup.
• Expand 02 - Python with comments and examples: The Python hello_world.py is minimal; add inline comments explaining Python syntax (indentation, type hints, common idioms) similar to depth expected in other language folders, plus 2-3 additional example files (variables.py, functions.py, classes.py).

This is an educational repository containing introductory programming examples in multiple languages. The codebase demonstrates minimal security risk as it consists primarily of simple 'Hello World' style programs and learning materials. No dependencies are directly exposed in the repository root, and the single Go module file (go.mod) specifies Go 1.20 without external dependencies. No hardcoded secrets, credentials, or sensitive configuration files were detected. The repository structure and content are appropriate for its intended purpose as a learning resource. Minor recommendations relate to general best practices rather than critical vulnerabilities.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.