Getting Started with AI-Powered Development: A Non-Engineer’s Guide to Claude Code, Cursor, and Git

How you can build software without knowing how to code

Level: Beginner
Time: 25-30 mins

---

If you’ve been wanting to jump into vibe coding. using the tools that the professionals use, you’re in the right place. You’ve probably invested some time into building apps with Replit, Lovable or Bolt, but now you want to get your hands dirty working locally on your machine and building something a bit more robust and complex—without spending hundreds on credits at Replit.

I’m documenting my journey building with AI tools, and I figured others might be on a similar path. So here’s what I wish someone had told me when I started: what these tools actually are, how they fit together, and the simplest way to get going.

---

Part 1: What Are These Things, Actually?

Let me cut through the hype and explain what these tools do in plain English.

Git: Your Time Machine

If you touched code in 2013, you know Git. It’s version control—the thing that saves your work and lets you undo mistakes.

Think of it like this:

• Commits = Save points in a video game

• Branches = Parallel universes where you can experiment

• GitHub = Cloud backup + portfolio

Why it matters now: AI generates code fast. Sometimes it goes in the wrong direction. Git lets you say “actually, go back to 20 minutes ago” instantly.

Get started: GitHub’s Git Handbook

Cursor: Your AI Pair Programmer in an Editor

Cursor is basically VS Code, but with ChatGPT/Claude built directly into your editor.

Instead of:

1. Writing code

2. Copying it to ChatGPT

3. Getting a suggestion

4. Copying it back

5. Hoping it works

You just:

1. Select your code

2. Hit Cmd+K

3. Tell it what to do

4. Accept or reject the changes

It sees your entire codebase, understands your project structure, and can edit multiple files at once.

The game-changer: It integrates AI capabilities directly with your codebase, allowing developers to write, refactor, and understand code faster using natural language prompts.

Get started: Download Cursor

Claude Code: Your AI Developer in the Terminal

Claude Code is different. It’s a command-line tool that can autonomously write code, run tests, fix bugs, and even commit changes.

Imagine telling an intern: “Build a login form with validation” and they just... do it. That’s Claude Code.

The difference from Cursor:

• Cursor = Interactive. You’re steering constantly.

• Claude Code = Autonomous. You give it a task and come back later.

Claude Code is a CLI that uses Anthropic’s latest models to generate code—you give it instructions in your terminal, and the built-in coding agent with its tools executes those commands.

Get started: Claude Code Setup Guide

---

Part 2: How They Work Together

Here’s my actual workflow building DeepWork OS:

Planning & Setup:

• Open Cursor

• Create a new feature branch in Git

• Use Cursor to scaffold components and write boilerplate

• Review everything visually with Cmd+K edits

Deep Implementation:

• Switch to Claude Code in terminal

• Give it bigger tasks: “Add authentication to the user dashboard”

• Let it work autonomously while I grab coffee

• It writes code, runs tests, iterates until tests pass

Review & Ship:

• Back in Cursor to review all changes

• Fix anything Claude Code missed

• Commit to Git with a descriptive message

• Push to GitHub

The Git layer: Every time AI makes progress, I save a checkpoint. If something breaks, I rollback. Simple.

---

Part 3: Setting Up (The Simple Solo Developer Way)

Let me be real with you: when I started this journey, I tried to learn everything at once. Big mistake. Here’s the order that actually works.

Week 1: Start with Just Cursor

Seriously. Don’t try to master both tools immediately. Get comfortable with one first.

Install Cursor

Installation:

1. Go to cursor.com

2. Download for your OS (Mac, Windows, or Linux)

3. Open it—if you’ve used VS Code, it’ll feel instantly familiar

First-time setup:

When you open Cursor for the first time:

1. Sign in (I use GitHub, but Google/email work too)

2. Choose your AI model - select Claude 4 Sonnet (it’s genuinely the best for coding right now)

3. If you have VS Code settings, Cursor will offer to import them

That’s it. You’re ready to code.

Your First 30 Minutes with Cursor

Let’s build something tiny so you see how it works.

Create a new file called hello.html:

1. Press Cmd+K (Mac) or Ctrl+K (Windows)

2. Type: “Create a simple HTML page with a button that shows an alert”

3. Hit Enter

4. Watch Cursor write the code

5. Review it, hit Accept

You just wrote your first AI-assisted code. See how that felt?

The Three Cursor Shortcuts You’ll Use Every Day

Cmd+K (Inline Edit)

• Select any code

• Press Cmd+K

• Tell it what to change

• Perfect for quick tweaks

Cmd+I (Composer)

• Opens a bigger AI panel

• Can edit multiple files at once

• Shows you a plan before making changes

• This is your main workhorse

Cmd+L (Chat)

• Ask questions about your code by switching to ‘Ask’ instead of ‘Agent’

• “Why isn’t this working?”

• “How do I add TypeScript here?”

• Like ChatGPT, but it knows your project

Create Your Project Rules

Here’s where Cursor gets really powerful. Create a file called .cursorrules in your project folder:

# .cursorrules

You are helping me build DeepWork OS, a productivity app.

## Rules
- Always write complete code, never use placeholders like “// rest of code here”
- Break complex tasks into smaller steps
- Explain your reasoning before making changes
- Use TypeScript for type safety
- Write tests for new features

The .cursorrules file provides system-level instructions that Cursor follows persistently—start small and add to it whenever Cursor makes the same mistake twice.

Save this file. Now every time you ask Cursor for help, it’ll follow these rules automatically.

Pro tip: You don’t need a long, complicated rules file. Start with 5-10 lines. Add more as you notice patterns in what you want.

Learn more: DataCamp’s Cursor Tutorial

---

Week 2: Add Git to the Mix

Once you’re comfortable with Cursor generating code, it’s time to add version control. This is your safety net.

Install Git

Check if you already have it:

git --version

If you see a version number, you’re good. If not, install from git-scm.com/downloads.

Set Up Your First Project with Git

# Navigate to your project folder
cd deepwork-os

# Initialize Git
git init

# Create a README
echo “# DeepWork OS” > README.md

# First commit (your first save point)
git add .
git commit -m “Initial commit”

Congratulations. You can now undo anything Cursor does that breaks your code.

Connect to GitHub (Your Cloud Backup)

1. Go to github.com and create a new repository called deepwork-os

2. Don’t add README or .gitignore (you already have them)

3. Copy the commands GitHub shows you:

git remote add origin https://github.com/yourusername/deepwork-os.git
git push -u origin main

Your code is now backed up in the cloud. If your laptop dies, you’re fine.

The Only Git Commands You Need (For Now)

# Create a new feature branch
git checkout -b feature/your-feature-name

# Save your work (do this every 30-60 minutes)
git add .
git commit -m “describe what you just built”

# Backup to GitHub (do this at end of each session)
git push origin feature/your-feature-name

# When feature is done and working, merge to main
git checkout main
git merge feature/your-feature-name
git push origin main

That’s it. Ignore all the advanced Git stuff for now.

Why this matters: Use version control aggressively—commit frequently so you can roll back if AI suggestions take your project in the wrong direction.

Learn more: GitHub’s Git Handbook

---

Week 3+: Level Up with Claude Code

Okay, you’ve been using Cursor for a couple weeks. You’ve shipped some features. You’re feeling good.

Now let’s add Claude Code—and here’s the cool part: it runs inside Cursor.

Install Claude Code

Open your terminal (or Cursor’s built-in terminal):

# macOS/Linux
curl -fsSL https://claude.ai/install.sh | bash

# Windows (in PowerShell)
irm https://claude.ai/install.ps1 | iex

When you first run it, it’ll ask you to authenticate. I use my Claude Pro subscription, but there are other options.

Running Claude Code Inside Cursor

Here’s where it gets interesting. You don’t need to switch between windows.

In Cursor:

1. Press Cmd+J (Mac) or Ctrl+J (Windows) to open the terminal panel

2. Type: claude

3. You’re now running Claude Code in Cursor’s terminal

Your screen looks like this:

┌─────────────────────────────────────┐
│   Your Code (Cursor’s editor)       │
│   - See files and changes           │
│   - Use Cmd+K for quick edits       │
│                                     │
├─────────────────────────────────────┤
│   Claude Code (terminal)            │
│   > Ready for your instructions     │
│   > Working autonomously...         │
└─────────────────────────────────────┘

As Claude Code writes code in the terminal below, you see the changes appear in your editor above. It’s like having two developers working at once.

Set Up Your Project for Claude Code

First thing to do: create CLAUDE.md in your project root:

# CLAUDE.md

## Project Overview
DeepWork OS - A productivity operating system for deep work sessions

## Tech Stack
- React + TypeScript
- Vite for bundling
- Tailwind CSS for styling

## Development Commands
- `npm run dev` - Start dev server
- `npm test` - Run tests
- `npm run build` - Production build

## Coding Standards
- Use functional components
- Write tests for new features
- Keep components small and focused

The /init command automatically generates project documentation that Claude uses to understand your complete project, including overview, tech stack, folder structure, and development conventions.

Save this. Now run in the Claude Code terminal:

/init

Claude will read your project, understand the structure, and generate comprehensive documentation. It’ll ask you questions to make sure it understands your setup.

Test it worked:

> what does this project do?
> explain the folder structure
> what technologies does this project use?

If Claude can answer these accurately, you’re golden.

Learn more: Claude Code Documentation

---

Cursor vs Claude Code: When to Use What

This confused me at first. Here’s how I think about it now:

Use Cursor’s Cmd+K for:

• Quick edits to one file

• Changing styling or UI

• Fixing a specific bug

• When you want to see changes immediately

Example:

Select a component → Cmd+K → “Add a loading spinner” → Done

Use Cursor’s Cmd+I (Composer) for:

• Creating new components

• Multi-file refactoring

• When you want to review a plan first

• Most of your day-to-day feature building

Example:

Cmd+I → “Create a settings page with tabs for account, preferences, and notifications” → Review plan → Accept

Use Claude Code (in terminal) for:

• Building something from scratch

• When you want it to run tests automatically

• Long autonomous work sessions

• Complex features where you can step away

Example:

claude --dangerously-skip-permissions
> Build a complete authentication system with login, signup, password reset, and email verification. Include tests for all flows.
[Go get coffee while Claude works]

The --dangerously-skip-permissions flag allows Claude to edit files and run commands without asking each time—it’s like Cursor’s old “YOLO mode” that doesn’t exist anymore.

The Pattern That Actually Works

Morning (Planning):

• Use Cursor’s Cmd+I

• Scaffold new features

• Set up file structure

Afternoon (Heavy Lifting):

• Open Claude Code in Cursor’s terminal

• Give it autonomous tasks

• Let it write tests and iterate

Evening (Polish):

• Back to Cursor’s Cmd+K

• Quick UI tweaks

• Review and commit everything

Many developers have abandoned Cursor’s agents entirely and live exclusively in Claude Code, finding that they default to Claude first and only peek at code when reviewing changes.

But when you’re starting? The visual feedback loop of Cursor is friendlier. The terminal-first approach can feel intimidating.

My advice: Master Cursor first. Add Claude Code when you want more autonomy.

---

Your First Real Feature: Using Both Tools Together

Let me walk you through building a Pomodoro timer using this workflow.

Step 1: Create a Feature Branch (Git)

git checkout -b feature/pomodoro-timer

Step 2: Scaffold with Cursor (Cmd+I)

Press Cmd+I in Cursor and type:

Create the basic structure for a Pomodoro timer:
- PomodoroTimer component
- usePomodoro hook for state management
- Timer display
- Start/pause/reset buttons

Review the plan Cursor shows you. Accept it. You now have your file structure and basic components.

Step 3: Implementation with Claude Code

Open terminal in Cursor (Cmd+J), start Claude Code:

claude --dangerously-skip-permissions

Then give it the heavy lifting:

Complete the Pomodoro timer implementation:
- 25-minute work sessions
- 5-minute break sessions
- Audio notification when time’s up
- Persist timer state to localStorage
- Write comprehensive tests covering all scenarios
- Make tests pass

Writing tests first, then having AI generate code, then running tests and updating code until tests pass provides a level of guarantee that AI-generated code behavior is correct.

Watch Claude Code work in the terminal while your editor shows the changes happening above. It’ll:

• Write the implementation

• Write tests

• Run tests

• Fix failures

• Iterate until everything passes

You can do other work while this happens, or just watch and learn.

Step 4: Polish with Cursor (Cmd+K)

Now you’re back in visual mode. Maybe the spacing is off, or you want different colors.

Select the component, press Cmd+K:

Make the timer display larger and use a monospace font
Add subtle animations when the timer updates
Use our brand colors for the buttons

Quick visual changes, immediate feedback.

Step 5: Review & Commit (Git)

# See what changed
git diff

# Stage everything
git add .

# Commit (ask Cursor to help write the message)
# In Cursor chat: “Generate a commit message for these changes”
git commit -m “feat: add Pomodoro timer with test coverage”

# Push to GitHub
git push origin feature/pomodoro-timer

Step 6: Merge When Ready

git checkout main
git merge feature/pomodoro-timer
git push origin main

Done. You just shipped a complete feature using AI for 80% of the work.

---

Do You Actually Need Both Tools?

Real talk: Start with just Cursor.

Cursor alone is incredibly powerful. Its Composer mode (Cmd+I) can handle most of what Claude Code does, and it’s more visual and beginner-friendly.

Add Claude Code when you:

• Want longer autonomous work sessions

• Need multiple AI agents working in parallel

• Prefer terminal-first workflows

• Feel limited by Cursor’s interactivity

You can run multiple Claude Code instances in parallel in different terminal panes as long as they’re working on different parts of your codebase—which is wild when you think about it.

But for your first month? Just Cursor is plenty.

---

The Setup Checklist

Here’s what you should have by the end of Week 3:

✅ Cursor installed and configured

• Claude 4 Sonnet selected as your model

• .cursorrules file created

• Familiar with Cmd+K, Cmd+I, and Cmd+L

✅ Git set up locally and remotely

• Repository created on GitHub

• Committing every 30-60 minutes

• Pushing to remote daily

✅ Claude Code ready (optional but recommended)

• Installed globally

• Can run in Cursor’s terminal

• CLAUDE.md file created

• Tested with /init command

✅ Comfortable with the workflow

• Feature branches for new work

• Cursor for planning and quick edits

• Claude Code for autonomous implementation

• Git commits after each logical chunk

---

Common Setup Questions

“Do I need a Claude Pro subscription?”

For Cursor: No, you can use the free tier to start. For Claude Code: You can authenticate via Claude Console (requires active billing), Claude App (Pro/Max plan subscription), or Enterprise platforms.

I pay for Claude Pro ($20/month) because I use both tools heavily. But start free and upgrade if you hit limits.

“Can I use GPT instead of Claude?”

Yes! Cursor supports multiple models. GPT-4.1 costs $2 per million input tokens and is optimized for frontend development, while Claude 4 delivers the best results for coding overall. Try both and see what you prefer.

“I’m overwhelmed. What’s the absolute minimum?”

Just Cursor + Git. That’s it. You can build real software with just those two tools. Add Claude Code in a month when you want more power.

“What if I break something?”

That’s why we use Git! Commit frequently so you can roll back if AI suggestions take your project in the wrong direction. Worst case:

git log  # See your commits
git reset --hard abc123  # Go back to that commit

Everything is fixable.

---

Next up: Your first week of building with AI. We’ll create actual features, not just tutorials.

But first—go install these tools and make sure they work. Don’t read ahead until you’ve got Cursor open and you’ve made your first Git commit.

Seriously. Close this tab. Install stuff. Come back when you’re ready.

I’ll be here.