Cursos en esta ruta
Product Thinking For Engineers
Takes an engineer out of "I execute tickets" mode and into thinking like product: stop measuring your work by outputs (features shipped) and start measuring it by outcomes (metrics that moved). This guide is the foundation of the Product Engineering ecosystem: it covers the build trap (teams that build a lot and move little), the product value chain (how a line of code turns into value for the user and the business), prioritization with criteria (RICE and ICE), opportunity sizing before building, the right MVP (the smallest experiment that proves the bet, not "v1 with fewer features"), treating every product decision as a bet under uncertainty with its riskiest assumption, and saying no with a roadmap ordered by cost of delay (WSJF). All the quantitative reasoning behind these frameworks — RICE, opportunity sizing, WSJF — runs as literal, executed Node.js code, on the same running case: the quarterly backlog of Mercado, the marketplace. It closes with a capstone project where you build Mercado's actual quarterly roadmap using everything you learned.
64 lecciones
Product Discovery And Prototyping
Teaches how to validate a bet with real users before building it. Building is the most expensive way to learn; this guide buys cheap evidence about risky assumptions before spending weeks of engineering time. It covers continuous discovery as a habit, not a one-time phase; interviews that don't lie — asking about past behavior, not future intentions, following the Mom Test approach; the opportunity solution tree for mapping the problem before jumping to a solution; turning an assumption into a falsifiable hypothesis and designing the cheapest test that can refute it (the riskiest assumption test); prototyping at the right fidelity level — paper, clickable, wizard-of-oz, fake door; avoiding confirmation bias and the say-do gap; and synthesizing findings to decide whether to continue, pivot, or kill the bet. It picks up exactly where the Product Thinking guide left off: Mercado's `recommendations` bet, with its riskiest assumption already identified but untested. All the decision logic — which test to pick, how to weigh evidence, how to update confidence — runs as executed Node.js code. It closes with a capstone project that validates that bet end to end.
64 lecciones
Product Metrics And Experimentation
Teaches how to measure whether a bet worked, with rigor: the quantitative side of product. It covers what to measure (North Star, actionable vs. vanity metrics, Google's HEART and McClure's AARRR/pirate metrics frameworks), how to read a funnel (conversion and drop-off by step), how to measure cohort retention without an aggregate average lying to you, how to protect a metric with guardrails, and — the heart of the guide — how to run A/B tests correctly: the hypothesis, randomization, lift, statistical significance (p-value and confidence interval via a real proportions z-test), sample size (MDE, statistical power), and the pitfalls that invalidate a result that looks good (peeking, multiple comparisons, Simpson's paradox, novelty effect). It picks up where the Discovery guide left off: Mercado's `recommendations` bet, already validated with a qualitative signal (fake door), now launches as a controlled experiment (`control` vs. `variant`) and gets measured with real statistics, implemented and verified in Node.js. It closes with a capstone project that measures the full launch and decides whether to ship, revert, or iterate.
64 lecciones
Evaluation Frameworks Guide
Master the evaluation of AI systems — from metrics for chat, RAG, and agents to LLM-as-judge, RAGAS, TruLens, and production evaluation pipelines. Learn to build golden datasets, implement domain-specific evaluation for chatbots, RAG pipelines, and AI agents, automate evaluation with calibrated LLM judges, and deploy continuous monitoring with CI/CD integration and regression detection.
64 lecciones
Shipping And Iterating Products
Teaches that "the A/B won" is not "flip it on for everyone": shipping a product change is its own risk decision, with a reverse gear. It closes the Product Engineering ecosystem by covering feature flags (decoupling deploy from release, kill switches for instant rollback without a redeploy), gradual rollout (canary 1% → 10% → 50% → 100%, with controlled blast radius at every stage), monitoring the launch (watching product guardrails during the ramp, and halting if they break), rollback and incident response (revert vs. fix-forward, the runbook, blameless incidents), blameless postmortems and the ship → measure → learn loop, and the modern layer of shipping AI safely (migrating models with shadow mode and canary, practical data privacy when launching). It picks up exactly where the Metrics guide left off: Mercado's `recommendations` bet won its experiment with real statistical significance, but broke a latency guardrail. All the launch decision logic (advance, halt, rollback) runs as executed Node.js code. It closes with a capstone project that ships that full bet and closes out the entire ecosystem arc.
64 lecciones
Product Strategy For Engineers
Moves an engineer from the tactical question ("what feature do I build?") to the strategic one ("what game are we playing, and how do we win?"). It covers vision and mission (where the product is going and why, and how a clear vision constrains what gets built), target segment and positioning (who this is for, and who it's explicitly not for), differentiation and value proposition (what separates a product from mere parity — the "table stakes" of copyable features), competitive and market analysis (direct competitors, indirect competitors, substitutes, and where the playing field is heading), moats and defensibility (durable advantages — network effects, switching costs, data, scale — versus a feature that gets copied in a weekend), and how strategy flows down to the roadmap as a filter that runs before RICE, cutting high-scoring bets that don't serve the strategy. It builds on the Product Thinking guide — strategy picks the game; product thinking plays it — and uses the same running case, Mercado, to define its full strategy and apply it as a filter over its real backlog. All the evaluation logic runs as executed Node.js code. It closes with a capstone project that defines Mercado's strategy end to end.
64 lecciones
Building with LLMs in Code
Integrate an LLM into a real product from code, not from an experimentation notebook. This guide works directly against the provider's SDK — on purpose, so you understand what a framework abstracts away before you adopt one — across eight modules: treating the LLM as just another dependency of your software (non-deterministic, billed by token), building your first serious integration with your own client, keeping prompts as versioned code, getting structured, validated outputs instead of parsing free text, giving the model tools through tool calling controlled by your code, streaming responses, hardening the integration against real provider failures, and evaluating and shipping with an eval suite that tells you whether a change made the system better or worse. The final project is a production-ready support-ticket triage service: Pydantic-validated classification, streaming responses, real tools, retries, caching, cost control, and evals running in CI.
64 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
The AI Coding Tools Landscape
Navigate the complete AI coding tools ecosystem with confidence. Evaluate Cursor (modes, rules, Cloud Agents), GitHub Copilot (Agent Mode, CLI agents, AGENTS.md), Cline (open-source, ACP), Windsurf (Cascade), and OpenAI Codex CLI. Build a personal decision matrix for evaluating tools objectively, develop a multi-tool strategy with Claude Code as your primary tool, and master AGENTS.md — the emerging standard adopted by 60,000+ repos. 6 progressive modules from tool evaluation to a configured personal toolkit.
36 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
Cost Optimization & Caching Guide
Master cost reduction for AI systems: understand cost drivers (tokens, API calls, embeddings), implement Redis caching and semantic caching (similar queries = cached responses using embeddings), apply prompt optimization and model selection strategies, and build a system that achieves 50-80% cost reduction with real numbers. The only guide in Spanish that covers semantic caching hands-on.
64 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