Cursos en esta ruta
Terminal and Command Line Guide
Learn to move around, inspect, compose, diagnose, and automate any machine — yours or a remote one you connect to over SSH — from the command line, without depending on a graphical interface or copying commands you don't understand. The guide starts from zero, opening the terminal for the first time, and moves through five modules: the terminal and the filesystem as a tree, working with files and text (creating, finding, reading, editing), pipes and redirection to compose commands like a language, permissions, processes, and environment variables, and remote machines, networking, and scripting. The final project is `ops-toolkit`: your own diagnostic kit with three shell scripts — environment verification, layered network probing, and a remote SSH report — that you run and defend live, not a screenshot.
40 lecciones
Software Development Foundations
Learn to think like a professional developer, not just write code: read an unfamiliar codebase and build a mental map of it, break down a fuzzy requirement into buildable pieces, and understand how code gets organized and why. This guide covers reasoning clearly about data, state, and edge cases before they blow up on you, turning an ambiguous "make it do X" into a spec with explicit questions and assumptions, and choosing between design alternatives knowing there's no right answer, only trade-offs. It also works through the feedback loop (edit, run, observe, adjust) as a discipline for making safe changes, and how to work on shared code as part of a team: code review, pull requests, and feedback. You work on Habitat, a real task-tracking app that a four-person team built fast and now has to maintain and grow; you come in as the new developer who didn't write that code and has to understand it. It closes with an end-to-end project: you receive a real request on Habitat and deliver it as a reviewable feature, applying the whole guide. It's the discipline that separates someone who "knows how to code" from someone who builds software other people can maintain.
64 lecciones
Git & GitHub Guide
Master version control with Git and collaborative development with GitHub, from your first commit to production CI/CD pipelines. This guide walks you step by step through everything you need to work professionally with Git: local workflow, branches, conflict resolution, Pull Requests, team workflows, automation with hooks and GitHub Actions, and error recovery. Built for developers of any language who want to stop fearing Git and start using it with confidence on real teams.
104 lecciones
Security for AI-Generated Code
45% of AI-generated code contains security flaws (Veracode 2025). Java: 72% failure rate. JavaScript: 43%. Python: 38%. XSS: 86% of AI code fails. Larger models don't generate more secure code. This guide teaches you to detect, prevent, and fix vulnerabilities in code produced by any AI tool — OWASP Top 10 applied to AI code, vulnerability patterns by language, detection tools, security review checklists, hardening techniques, and secrets management.
32 lecciones
Design Patterns
Learn to read someone else's code and name what you see — "this is a Strategy," "there's a God object here" — and, above all, to know when a pattern earns its complexity and when NOT to abstract, because every pattern adds indirection and indirection is a cost you pay. This guide isn't a catalog of the 23 GoF patterns to memorize: it covers the ones that actually show up in real code and in reviews, organized by the problem they solve — behavior that varies (Strategy, Template Method, State), creating objects (Factory, Builder, why you should distrust the Singleton), structure and adaptation (Adapter, Facade, Decorator, Composite), and communication between parts (Observer, Command). It also teaches the rule of three, YAGNI, and premature abstraction as the costliest mistake, and how to use patterns as review vocabulary: naming code smells (God object, feature envy, shotgun surgery) so a problem becomes actionable. You work on Boletia, an event-ticketing platform where everything varies — notification channels, payment providers, ticket types — and that also has the opposite problem: a plugin architecture built for something that will only ever have one implementation. It closes with a capstone project where you remove an abstraction that doesn't earn its keep and introduce the pattern that truly emerges from a 300-line checkout, in small, safe steps.
64 lecciones
Clean Code And Code Review
Learn to write code someone else can read without suffering, and to take part in a review as a professional in both seats: the one proposing — packaging a change, writing the pull request that explains it, and defending your decisions without getting defensive — and the one reviewing — knowing what to look at first, what to comment on and what to let go, and how to say what you see without the other person shutting down. You don't come out with a memorized list of style rules: you come out knowing why each rule exists, when to break it, and how to talk about code with people who don't think like you do. The eight modules revolve around Cardumen, a 14-person startup with a broken review culture — PRs approved in two minutes with an "LGTM", dreaded reviews, people who stopped proposing big changes — and move from readable code to signals that something is rotting, to the change as a unit of communication, to reviewing someone else's code, to the hard conversation, to standards a team actually follows, to reviewing AI-written code, and close with the full loop of a real day of work.
64 lecciones
Debugging and Troubleshooting
Take an unknown failure — a thirty-line traceback, a silently wrong result, a regression buried under two hundred commits, or a test that fails once every thirty runs — and learn to reproduce it, corner it down to the exact line, and explain it with evidence, before asking a model anything; and when you do ask, learn to verify whether the answer is correct. The six modules move from reading the failure (what a traceback is already telling you) to the method that goes from symptom to root cause, to the debugger for stopping the program and looking inside, to logging for diagnosing what already happened, to bisection for cornering regressions and intermittent failures, and close with AI in the loop: using it after you understand the error, not instead of understanding it. The final project is a debugging dossier on a repository with five failures of different natures — including a regression that requires `git bisect run` — resolved with protocol, evidence, and a regression test.
48 lecciones
Working with Coding Agents
Learn to direct coding agents as a professional craft, not improvisation. This guide covers the six pieces that separate amateur use from professional use: the craft of directing instead of writing code directly, spec-driven development, harness engineering — the environment, context, and permissions you set up so the agent can verify itself — verifying and reviewing what the agent generates, budgeting and controlling token and time cost, and governing AI-generated code within a team. By the end, you can write executable specifications, prepare an agent-ready repository, review — not just accept — what an agent produces, control how much you spend in tokens and human attention, and write the playbook that governs how your team works with agents.
48 lecciones
Technical English and Employability
Learn to work and apply for jobs in English: read documentation without translating, write PRs, bug reports, and design documents in plain English, hold your own in a standup and a demo out loud, and run a job search with market judgment. The seven modules start from your actual target — the role, the market, and the English gap that separates you from it — and move through the fundamentals of reading and listening to technical English, written async communication (chat, issues, PRs, commits), writing technical documents in plain language (design docs, ADRs, READMEs, postmortems), spoken technical English (standups, meetings, pair programming, demos), your professional materials (an ATS-ready résumé, LinkedIn, portfolio), and the full hiring process. The final project is the Employability Kit: a cumulative, interview-defensible dossier with your target-role brief, a portfolio with a design doc and ADR, an async communication package, a tailored résumé, and three unscripted English recordings — a pitch, a demo, and a mock interview.
56 lecciones