How to Use AI Tools in Coding Without Losing Your Fundamentals: A Developer's Guide Inspired by Stanford's Youngest Instructor

Overview

In a recent podcast, Quincy Larson interviewed Rachel Fernandez, a computer science student at Stanford and the university's youngest instructor. Rachel shared deep insights on the state of computer science education in 2026, the enduring relevance of C++, and how developers can leverage AI tools without deskilling themselves. This tutorial transforms those insights into a practical guide for developers who want to integrate AI assistants into their workflow while preserving—and even strengthening—their core programming skills. You'll learn a structured approach to using AI for coding, with real-world examples from Rachel's experience teaching C++ and catching cheaters at Stanford's TreeHacks hackathon. By the end, you'll have a framework to augment your abilities, not replace them.

How to Use AI Tools in Coding Without Losing Your Fundamentals: A Developer's Guide Inspired by Stanford's Youngest Instructor — Source: www.freecodecamp.org

Prerequisites

Before diving in, ensure you have:

Basic programming knowledge in at least one language (Python or C++ preferred for this guide).
Familiarity with command-line tools and version control (Git).
An account on an AI coding platform (e.g., GitHub Copilot, ChatGPT, or Claude).
(Optional) A C++ compiler installed for the code examples—g++ or clang++ works.
A willingness to deliberately practice without AI assistance for part of the workflow.

Step-by-Step Instructions

Step 1: Understand the Deskilling Trap

Rachel warns that blindly accepting AI-generated code can erode your ability to debug, reason about algorithms, and write idiomatic code. Before using any AI tool, explicitly set a goal: “I will understand every line the AI produces.” Start with a simple C++ problem—like implementing a function to find the factorial of a number—and write it manually first. Then ask the AI to generate an alternative solution. Compare the two, noting differences in style and efficiency.

Example: Write your own factorial function in C++:

unsigned long long factorial(int n) {return (n <= 1) ? 1 : n * factorial(n - 1);}

Now prompt the AI: “Generate a C++ factorial function using iteration instead of recursion.” Analyze the iterative version to reinforce your understanding of stack vs. heap memory.

Step 2: Use AI for Learning C++ Subtleties, Not Skipping Them

Rachel, who teaches C++ at Stanford, emphasizes that AI is excellent for exploring language nuances—like template metaprogramming, RAII (Resource Acquisition Is Initialization), and move semantics—but dangerous if you use it to avoid learning them. Choose a complex C++ concept, such as smart pointers (std::unique_ptr), and ask the AI to explain it with a complete example. Then, modify the example by introducing a deliberate bug (e.g., double-free) and see if the AI catches it. This exercise builds both your understanding and your debugging skills.

Code snippet for experimentation:

#include <memory>#include <iostream>struct MyClass { ~MyClass() { std::cout << "destroyed\n"; } };int main() {std::unique_ptr<MyClass> p1 = std::make_unique<MyClass>();// Ask AI: What happens if I reset p1 and then delete the raw pointer?}

Step 3: Create a Personal Project with Guardrails

Rachel helped organize TreeHacks, where 1,000 participants built projects over a weekend. You can simulate this by setting a 48-hour timer for a mini-project (e.g., a command-line chat app in C++). Use the AI only during specific phases: starting with brainstorming ideas, then moving to implementation. Implement the first 30% of the code yourself. For the remaining 70%, use the AI to generate code stubs—but disable AI for the core logic or security-sensitive parts (like authentication). This mimics the “catch cheaters” aspect: you’re forcing yourself to own the critical pieces.

Step 4: Integrate AI Responsibly into Your Daily Flow

Develop a habit of reviewing and rewriting every AI suggestion. Use these specific techniques:

Commit without AI: Write a function, commit it, then ask AI for improvements. Compare the diff and merge only what you fully grasp.
Test before accepting: Always run any AI-generated code through your unit tests. If tests fail, debug manually—don’t ask AI to fix it.
Audit for security: Rachel’s background in InfoSec makes this crucial. Check for buffer overflows, injection vulnerabilities, and memory leaks in C++ code produced by AI. Use tools like Valgrind to verify.

Step 5: Learn from Others’ Projects and AI Governance

freeCodeCamp recently published a handbook on AI Governance, which includes Python projects for bias detection, audit logs, and human-in-the-loop systems. Rachel’s comments on catching cheaters align with this: as developers, we must build responsible AI into our own tools. Implement a simple human-in-the-loop check: before deploying any AI-generated code to production, have a colleague (or a future you) approve it. This reinforces the non-deskilling habit.

Common Mistakes

Over-reliance on AI completions: Developers often tab-complete without reading the output. Result: code that compiles but has logical errors or security flaws. Fix: Set a rule to never accept a suggestion without reading every character.
Using AI to avoid debugging: When stuck, many paste the error directly into the AI chat. Instead, try to debug for at least 15 minutes manually. If you still need help, ask the AI to explain the error concept, not provide a fix.
Ignoring language-specific idioms: AI models sometimes generate code that isn’t idiomatic for the language. For example, C++ generated with excessive new and delete instead of smart pointers. Fix: Cross-reference generated code with a style guide (e.g., C++ Core Guidelines).
Not updating your own mental model: After solving a problem with AI, try to reproduce the solution from memory a day later. If you can’t, you’ve deskilled. Use spaced repetition for key concepts.

Summary

This guide, inspired by Rachel Fernandez’s insights from her podcast appearance, provides a structured approach to using AI in coding without sacrificing your fundamentals. By manually implementing code first, deliberately practicing C++ nuances with AI as a tutor rather than a crutch, and enforcing guardrails during project development, you can augment your skills while staying sharp. The key takeaway: AI should amplify your understanding, not bypass it. Combine these techniques with freeCodeCamp’s resources on data quality, automation, and AI governance to build a complete, responsible development workflow.