Skip to main content

Part 2: AI Tool Landscape

Now It's Time to Get Your Hands Dirty​

Picture this: You've just finished Part 1. You understand the transformation. You know why AI-driven development matters. You're ready to start building.

But there's a problem.

You open your terminal (or maybe you've never opened one before), and you're staring at a blank screen. You've heard about Claude Code, Gemini CLI, and GitHub. You know they're powerful. You have no idea where to start, what these tools actually do, or which one is right for you.

This part solves that problem. By the end of these four chapters, you won't just know about AI development tools—you'll have them installed, configured, and ready to use. You'll understand the command line well enough to navigate confidently. You'll have Git and GitHub set up for professional development. And you'll know exactly which tool to reach for in any situation.

More importantly, you'll experience the paradigm shift from Part 1 becoming reality. The tools described theoretically in earlier chapters are now in your hands, ready to collaborate with you on real work.

What Makes This Part Different​

Part 1 was about understanding. Part 2 is about becoming capable.

Three characteristics make this possible:

First, these tools are accessible to everyone. In 2020, setting up a professional development environment meant hours of configuration, cryptic error messages, and frustration. Today, Claude Code and Gemini CLI can be installed in minutes. Bash tutorials that once required memorization can now be navigated with natural language prompts to an AI assistant. This accessibility means you don't need to be a "command line expert" to be productive—you need curiosity and willingness to learn alongside AI tools.

Second, the tools are designed for collaboration. Claude Code doesn't just give you advice—it can read your actual codebase, understand your project structure, and make changes directly (with your approval). Gemini CLI's massive 1 million token context window means it can see your entire project at once. These aren't passive assistants; they're active collaborators designed to work inside your development environment.

Third, safety mechanisms are built in from the start. Git (which you'll master in Chapter 8) acts as a complete safety net. Every change is tracked. Every experiment can be rolled back. GitHub creates a professional backup and portfolio. When you work with AI agents modifying your code, these mechanisms become non-negotiable—and they transform your development process into something safer and more intentional than traditional development.

This is what "learning WITH AI" looks like in practice.

What You'll Learn in Part 2​

This part consists of four interconnected chapters that build practical proficiency with AI development tools and professional workflows.

Chapter 5: How It All Started—The Claude Code Phenomenon​

Estimated time: 2-2.5 hours

You'll install and configure Claude Code, understanding why this "simple" command-line interface triggered such rapid adoption. We explore the origin story (how an internal Anthropic tool became a public phenomenon), walk through a straightforward npm installation, and learn Claude Code's key features through hands-on experience: subagents for specialized tasks, agent skills for autonomous discovery, and MCP servers for external data access.

This chapter establishes Claude Code as a collaborative thinking partner—not an automation supercomputer. By the end, Claude Code will be running on your machine with your first subagent and skill working, and you'll have experienced the paradigm shift from passive AI assistance to active AI collaboration.

What you'll accomplish:

  • ✅ Install Claude Code with a single npm command
  • ✅ Authenticate and run your first collaborative workflow
  • ✅ Create a simple subagent that explains code (not generates it)
  • ✅ Understand agent skills and autonomous discovery
  • ✅ Connect to GitHub via MCP and explore live repository data
  • ✅ Recognize how Claude Code differs from web-based AI chat

Chapter 6: Google Gemini CLI—Open Source and Everywhere​

Estimated time: 2-3 hours

Not everyone wants to use Claude Code. Not everyone should. This chapter introduces Gemini CLI, Google's open-source alternative that anyone can download, modify, and extend. You'll explore Gemini 2.5 Pro's massive 1 million token context window, install and configure Gemini CLI, and develop a framework for comparing tools.

The goal isn't "which tool is better"—it's "which tool is right for my specific situation?" By the end of this chapter, you'll be able to evaluate AI development tools critically and choose the right tool for different tasks.

What you'll accomplish:

  • ✅ Install Gemini CLI and configure authentication
  • ✅ Understand Gemini's open-source nature and free tier
  • ✅ Experience Gemini 2.5 Pro's capabilities firsthand
  • ✅ Compare Claude Code vs. Gemini CLI objectively
  • ✅ Develop criteria for choosing between tools

Chapter 7: Bash Essentials for AI-Driven Development​

Estimated time: 3-4 hours

The command line is the native language of serious development. This chapter is split into two parts: Part I teaches essential Bash commands (navigation, file operations, environment variables, scripting basics). Part II shifts perspective: instead of memorizing commands, you learn to request AI tools execute Bash commands via natural language prompts.

The practical focus: master the 90% of Bash workflows that matter for AI-driven development. Skip the esoteric corner cases. Focus on what you actually use.

What you'll accomplish:

  • ✅ Navigate the filesystem confidently (cd, ls, pwd, find)
  • ✅ Manipulate files and folders securely (cp, mv, rm, mkdir)
  • ✅ Set environment variables and work with API keys
  • ✅ Understand how to request AI tools execute Bash commands
  • ✅ Know when to "learn the command" vs. "ask AI to help"

Chapter 8: Git & GitHub for AI-Driven Development​

Estimated time: 3-4 hours

Git and GitHub aren't optional when working with AI agents—they're essential safety mechanisms. This chapter is also split into two parts: Part I covers essential Git commands (init, add, commit, push, branches, pull requests). Part II shows natural language workflows for requesting AI tools handle Git operations.

Critical insight: Git provides the safety net that makes AI-assisted development viable. Every change is tracked. Every experiment can be rolled back. Every collaboration is auditable. You'll learn why this matters before learning the mechanics of how to do it.

What you'll accomplish:

  • ✅ Initialize Git repositories and understand version control basics
  • ✅ Create commits that tell a story of your development process
  • ✅ Use branches for safe experimentation with AI-generated code
  • ✅ Create pull requests and review AI-assisted changes
  • ✅ Build a GitHub portfolio demonstrating professional practices
  • ✅ Use Git as a safety mechanism when working with AI agents

What You Won't Learn (Yet)​

This part is hands-on and operational, not theoretical. You're learning practical tool proficiency, not deep algorithmic understanding.

Specifically, you won't learn:

  • Deep algorithms or data structures (Part 4 onward)
  • Advanced system administration or DevOps practices (Parts 10-11)
  • How to write Python code or build applications (Part 4 onward)
  • Cloud deployment architecture (Parts 10-11)
  • Production-grade security hardening (covered progressively in later parts)

What you will get is practical competence: You'll have professional tools installed, understood, and ready to use. You'll know how to navigate a terminal confidently. You'll have version control workflows that professional teams use. This is the foundation for everything that follows—and notably, it's not optional. Professional development requires these skills.

How to Read This Part​

Take it slow and hands-on. Unlike Part 1 (which emphasized reading and reflection), Part 2 emphasizes doing. You should have your computer open. You should follow along with installations. You should run commands. You should make mistakes and recover with Git.

Follow the scaffolding. Chapter 5 (Claude Code) provides heavy support—step-by-step walkthroughs, detailed explanations, troubleshooting guides. By Chapter 8 (Git & GitHub), the support becomes lighter. You're expected to be more independent. This is intentional: we're building your confidence progressively.

Expect confusion, then clarity. The command line is unfamiliar to many people. That's normal. You don't need to understand everything immediately. Use AI tools (Claude Code or Gemini CLI!) to ask questions about commands you don't understand. This is "learning WITH AI" in practice.

Platform matters. Chapters 7 and 8 provide Windows-specific, Mac-specific, and Linux-specific instructions because terminal behavior differs significantly. Find your platform and follow those instructions carefully. If something doesn't work, ask your AI assistant to debug it based on your error message—that's what they're designed for.

A Note on Mindset​

The most important thing you'll develop in this part isn't tool proficiency—it's the ability to see AI tools as collaborators, not magic.

Many people approach new tools with one of two extremes:

The first extreme: "This is magic. I don't need to understand it. I'll just use it." This leads to magical thinking. When something goes wrong, you're helpless. When a tool acts unexpectedly, you have no mental model to understand why. You become dependent on the tool rather than in control of it.

The second extreme: "I need to understand everything about how this works before I use it." This leads to paralysis. You spend months studying command-line architecture before writing your first program. You read Git documentation obsessively before making your first commit.

There's a middle path: Understand tools well enough to use them effectively, ask questions when confused, make mistakes safely (using Git as your safety net), and learn through experimentation.

This part teaches you that middle path. Claude Code and Gemini CLI are powerful because they're designed to be understood progressively. You don't need to be an expert before using them. You need curiosity, willingness to experiment, and the ability to ask good questions when confused.

Bash and Git work the same way. You'll learn the 20% of commands that handle 80% of your work. You'll use AI tools to help with the other 20% when needed. This is professional workflow in 2025—not memorization of obscure commands, but knowing how to ask for help effectively.

Prerequisites​

You absolutely need:

  • ✅ Completion of Part 1: Introducing AI-Driven Development (the mindset foundation is critical)
  • ✅ A computer with internet access (Windows, Mac, or Linux)
  • ✅ Basic computer literacy (file management, using a web browser)
  • ✅ An email address and willingness to create API accounts

You don't need:

  • ❌ Terminal experience (we start from zero)
  • ❌ Prior knowledge of Git or version control
  • ❌ Programming experience (code comes later)
  • ❌ Any specific hardware or software

Take your time. Don't rush. Use your AI assistant (Claude Code or Gemini CLI) when you're confused. Make mistakes and use Git to recover. By the end of these four chapters, you'll have the foundation every professional developer relies on.

Let's get started.