Getting Started with Agentic Dev — Part 1: Your Toolkit

If you've been anywhere near the software development world lately, you've probably heard the term "agentic development" thrown around. Maybe you've seen demos of AI agents writing code, creating pull requests, and running tests — all from a single prompt. Maybe you've thought "that looks cool, but where do I even start?"

This series is your answer.

This is Part 1 of a 3-part series on getting started with agentic software development.

• Part 1: Your Toolkit (you are here) — Install and configure everything you need
• Part 2: Your First Workflow (coming soon) — Guardrails, planning, and your first prompt-to-PR cycle
• Part 3: Advanced Workflows (coming soon) — Multi-agent patterns, custom commands, and scaling up

The series takes you from zero to productive. Part 1 covers tooling — getting every piece of software installed and ready to go. Part 2 walks you through your first real workflow with an agent. And Part 3 pushes into advanced territory: multi-agent orchestration, parallel workstreams, and custom commands that encode your development process.

But first, let's get you set up.

What Is Agentic Development?

In short: agentic development is writing software with AI agents instead of just using AI autocomplete. Rather than getting one-line suggestions as you type, you give an agent a task — "add input validation to this form," "refactor this service to use dependency injection," "create a REST endpoint for user profiles" — and it reads your codebase, makes a plan, writes the code, runs the tests, and delivers the result for you to review.

The agent doesn't just complete your line. It completes your intent.

The tooling has matured to a point where this is genuinely practical for everyday work — not just demos. But you need the right setup. That's what this post is about.

Terminal — Your Command Center

Everything starts here. Agentic development is terminal-first. The AI agents you'll be working with run as CLI tools, so you'll want a terminal you're comfortable spending time in.

You have great options:

• Mac Terminal — Already on your Mac. No install needed, and perfectly fine to start with. If you've never opened Terminal before, you'll find it in Applications > Utilities.

• iTerm2 — The power-user favorite. Split panes, search, profiles, and a ton of customization. Free and open source. Install it with brew install --cask iterm2 (once you have Homebrew — next section).

• Warp — A modern, AI-native terminal with built-in agent capabilities, command history search, and collaborative features. If you like the idea of your terminal itself being smart, Warp is worth a look.

My recommendation: pick one and get comfortable. You can always switch later. The important thing is that you have a terminal open and ready to go.

Windows/Linux note: On Windows, Windows Terminal with WSL2 gives you a great Linux-based development experience. On Linux, your default terminal emulator works fine, or try Alacritty or kitty for something more modern.

Homebrew — The Package Manager That Makes Everything Else Easy

If you're on a Mac and you don't have Homebrew yet, this is the single most impactful install you'll do today. Nearly every tool in this guide can be installed with a single brew install command.

Install it by pasting this into your terminal:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Once it's installed, verify it works:

brew --version

That's it. Homebrew is your gateway to everything below. When I say brew install something, you'll know what I mean.

Windows/Linux note: On Linux, Homebrew works too — docs here. On Windows with WSL2, same deal. Alternatively, use your distro's package manager (apt, dnf, etc.) for most of these tools.

SDK / Runtime — Your Language Tooling

Agentic development is language-agnostic. The agents don't care if you write Java, Python, JavaScript, Go, or Rust. But you need the right runtime installed for whatever you plan to build.

Here are the quick installs for the most common languages:

# Node.js (JavaScript/TypeScript)
brew install node

# Python
brew install python

# Java
brew install openjdk

# Go
brew install go

Install whatever you need for your projects. If you're not sure, Node.js and Python cover the widest range of tutorials and examples you'll encounter.

Version managers

If you work across multiple projects that need different language versions, version managers are your friend:

• nvm — Node Version Manager. Switch between Node versions per project.
• pyenv — Python version manager. brew install pyenv
• SDKMAN! — Manages Java, Kotlin, Gradle, Maven, and more. Great if you're in the JVM ecosystem.

You don't need version managers to get started, but they save headaches down the road.

Git + GitHub CLI — Version Control Is Non-Negotiable

If there's one thing that's true about working with AI agents, it's this: version control isn't optional. Agents create files, modify code, and make changes across your project. You want Git tracking every move so you can review, revert, and stay in control.

Git

brew install git

If you're brand new to Git, the basics you need right now are git init, git add, git commit, and git push. There are a million tutorials out there, but you'll pick it up fast once you start working with agents — they'll be doing most of the Git operations for you.

GitHub CLI

brew install gh
gh auth login

The GitHub CLI (gh) is the tool that bridges your terminal and GitHub. You can create repos, open pull requests, manage issues, and review code — all without leaving the command line.

Why does this matter for agentic development? Because agents use gh to do things like:

• Create feature branches
• Push code and open pull requests
• Comment on and close issues
• Check CI/CD status

When an agent can interact with GitHub through gh, it can handle the full development lifecycle — from reading an issue to shipping a PR. That's a huge unlock.

Coding Agents — The Core of Agentic Development

Here's the main event. These are the AI agents that will actually read your code, understand your project, and write software alongside you.

Claude Code

Anthropic's CLI coding agent. This is the one I use daily and the one this series will reference most.

brew install claude-code

Or if you prefer npm:

npm install -g @anthropic-ai/claude-code

Claude Code reads your entire codebase, understands your project structure, and can execute multi-step tasks: writing code, running tests, creating commits, and opening PRs. It's the tool that made agentic development click for me.

Codex

OpenAI's open-source CLI agent.

npm install -g @openai/codex

Codex takes a similar approach — give it a task, it reads your code, makes a plan, and executes. It's open source, which means you can dig into how it works and contribute.

Gemini CLI

Google's CLI agent powered by Gemini.

npm install -g @google/gemini-cli

Gemini CLI brings Google's models to your terminal with a similar agentic workflow.

Which one should I pick?

You don't need all three. Pick one to start with. I recommend Claude Code for this series because it's the one I know best and the one I'll use in examples. But the concepts transfer across all of them. Once you learn to work with one agent, switching to another is straightforward — the workflow is the same, the model behind it is different.

IDE — Where You Read and Review

Here's something that surprised me about agentic development: the IDE becomes less of a writing tool and more of a reviewing tool. When an agent writes your code, you need a great environment to read through what it produced, understand the changes, and approve or adjust.

• VS Code — Free, massive extension ecosystem, GitHub Copilot built-in. The default choice for most developers. brew install --cask visual-studio-code

• Cursor — A VS Code fork purpose-built for AI-assisted coding. It has deep AI integration for chat, code generation, and inline editing. If you want an IDE designed around AI from the ground up, this is it. brew install --cask cursor

• Google Antigravity — Google's agent-first IDE, built around Gemini. It manages multiple agents across editor, terminal, and browser from a central mission control view. If you're invested in the Google ecosystem, worth exploring.

• JetBrains IDEs — IntelliJ IDEA, WebStorm, PyCharm, and friends. Incredibly powerful for their respective languages, with AI Assistant built in. If you're already a JetBrains user, no reason to switch. brew install --cask intellij-idea-ce

My take: use whatever IDE you're already comfortable with. The CLI agents run in your terminal independent of your IDE, so there's no lock-in. You'll have the agent in one window and your IDE in another, reviewing what it builds.

Validation — Confirm Everything Works

You've installed a lot of stuff. Let's make sure it all works. Run through this checklist:

# Terminal basics
echo "Terminal works!"

# Homebrew
brew --version

# Your language runtime (pick the ones you installed)
node --version
python3 --version
java --version

# Git
git --version

# GitHub CLI
gh --version

# Your chosen coding agent
claude --version        # Claude Code
# codex --version       # Codex
# gemini --version      # Gemini CLI

If all of those return version numbers without errors, you're in great shape.

For the final test, try this: navigate to any project directory (or clone one) and start your coding agent:

cd ~/some-project
claude

Ask it something simple: "What does this project do?" or "Explain the main entry point."

If you can open a terminal, ask an agent to explain a file, and see a clear response — you're ready for Part 2.

What's Next

You now have everything you need to start working with AI coding agents. A terminal, a package manager, your language tooling, Git, GitHub CLI, a coding agent, and an IDE for reviewing code. That's the full toolkit.

In Part 2, we'll put these tools to work. You'll learn how to set up guardrails so agents follow your project's conventions, how to plan before you prompt, and you'll walk through your first complete agentic workflow — from a task description to a merged pull request.

The setup is the easy part. The workflow is where it gets interesting.

Continue the series

Next: Part 2 — Your First Agentic Workflow

–Jeremy