Someone used Claude Code and Opus 5.5 to rebuild Adobe's entire software catalog in Rust. Photoshop, Premiere Pro, Lightroom, After Effects. Open source on GitHub, cloneable today. They wrote zero lines of code themselves. This guide covers how Claude Code actually works as an autonomous agent, the six patterns behind that kind of output, and what the project means for every subscription tool you currently pay for.
What Claude Code Actually Is
Not a chat tool. An agent that runs your computer.
Claude Code runs in your terminal. It reads your files, writes code, executes commands, and keeps going until the job is done. You give it a task in plain English. It figures out the rest.
This is a different mental model than any chat-based AI tool. Chat tools respond to prompts. Claude Code acts on tasks. It builds a map of your project, catches dependencies, and iterates when something fails, without you typing the next message.
When someone rebuilt Adobe's entire software suite with Claude Code and Opus 5.5, they did not write a single line themselves. They described what they wanted. Claude Code built it, tested it, and committed to GitHub. The result is now publicly cloneable.
That is the tool working correctly. This guide shows you how to run it the same way.
Step One: Install and Start in 5 Minutes
Install Claude Code from your terminal:
Copy this.
npm install -g @anthropic-ai/claude-code
Navigate to your project folder and start a session:
Copy this.
cd my-project claude
From there, describe what you want to build in plain English. No special syntax. No commands to memorize.
| Task type | What to say |
|---|---|
| Start a project from scratch | "Build a simple Express server with two endpoints: GET /health and POST /data" |
| Add a feature | "Add user authentication using JWT tokens" |
| Fix a bug | "The login form is returning 401. Read the auth module and fix it." |
| Explore a codebase | "Read the whole project and tell me what each file does" |
Your first real run: Start a new session in any project directory you have. Ask it: "Read the whole project and tell me what each file does." Do not ask it to change anything. Just read the summary it produces. That alone is useful in under two minutes.
The mistake that makes Step One fail: Treating Claude Code like a chat tool and asking broad, conversational questions. "Help me improve my project" produces nothing actionable. "Add input validation to the /signup endpoint using the existing pattern in /login" produces a diff you can review and push. Specific task, specific output.
Step Two: Work With an Existing Codebase
Claude Code reads your project files automatically when you start a session in that directory. It builds a full map before touching anything. It catches dependencies, existing patterns, and potential conflicts before making changes.
Three patterns worth using from day one:
Explore before editing. Start every session on a new codebase with: "Read the whole project and summarize the architecture before making any changes." This one prompt prevents most unintended side effects. It takes 60 seconds and it changes what Claude Code does next.
Targeted edits. Use scope guards on every edit that touches shared components: "Only modify the authentication module. Do not touch anything else." Claude Code respects this. When you leave scope open, it sometimes does more than you wanted.
Clone and adapt. Point Claude Code at a GitHub repo URL and ask it to clone, read, and adapt for your use case. This is the pattern behind the Adobe project. One repo. One task description. Complete rebuild in a different language.
Your first real run: Take a file in an existing project that you have been meaning to clean up. Tell Claude Code: "Read this file and refactor it to use async/await instead of callbacks. Do not touch any other file." Review the diff. Push if it looks right.
The mistake that makes Step Two fail: Skipping the explore step on unfamiliar code. Claude Code will make changes that break things it did not know were connected. Read before you edit. Every time.
Step Three: Build Software From Scratch
The pattern for building something new is simple: describe what the software does, not how to build it. Give Claude Code the goal. Let it choose the implementation.
Copy This: The Build Prompt
Copy this.
Build a web scraper that: - Takes a list of URLs as input - Extracts the page title and first paragraph from each - Saves results to a JSON file - Handles errors gracefully (timeout, 404, etc.) Use Node.js. No external scraping libraries.
Claude Code picks the approach, writes the code, tests it, and iterates when it fails. Your job is to review the output and redirect when it goes wrong.
For bigger builds, break them into phases: "Phase 1: data layer. Phase 2: API. Phase 3: frontend." Run each phase as a separate session. After each one, ask: "Summarize what you built and what the next phase needs to know." This summary becomes the first message of the next session.
One persistent tool: put a CLAUDE.md file in your repo root. Write your standing instructions there. Project conventions, naming rules, frameworks to use, things to avoid. Claude Code reads this automatically on every session start. You stop repeating yourself.
Your first real run: Open an empty folder. Tell Claude Code: "Build a simple command-line tool in Python that takes a URL as input, fetches the page, and counts how many times each word appears. Output the top 10 words and their counts." Run what it builds. See how long it takes.
The mistake that makes Step Three fail: Not reviewing before pushing. Claude Code produces working output most of the time. It produces plausible-looking broken output some of the time, especially on complex logic. Read every diff before it hits your main branch.
Step Four: Use GitHub Without Leaving the Agent
Claude Code works with Git natively. You do not need to switch to the terminal.
Ask it to:
- Clone a public GitHub repo and start immediately
- Create a feature branch before making changes
- Commit changes with a meaningful message it writes itself
- Read an existing PR and suggest improvements
Copy This: The GitHub Workflow Prompt
Copy this.
Clone this repo: [URL]
Create a branch called feature/add-rate-limiting
Add rate limiting to the API endpoints
Commit with a clear message when done
For private repos, authenticate via GitHub CLI or SSH before starting Claude Code. It uses whatever credentials are already configured on your machine. It does not need passwords in the chat.
Your first real run: Open an interesting public repo on GitHub. Paste the URL into a new Claude Code session and say: "Clone this repo, read the architecture, and summarize what it does and how it works." You get a useful overview in two minutes with zero reading on your part.
The mistake that makes Step Four fail: Starting Claude Code in the wrong directory. If you open Claude Code at your home folder instead of inside the project, it has no project context. Always cd into the project folder before running claude.
Step Five: Working at Scale
Breaking large projects into phases works for multi-day or multi-week builds. A few patterns that hold up:
The context pass-through. End every session: "Write a CONTEXT.md file summarizing what exists, what the next step is, and what decisions we made." Start the next session: "Read CONTEXT.md and pick up from there." This bridges sessions without losing state.
Parallel agents. Claude Code can run multiple instances. If your project has independent components, run them in separate terminal sessions simultaneously. One session builds the API. Another builds the frontend. Merge when each is done. Token cost per session is lower when the scope is narrow.
The audit loop. After any large build session, ask: "Audit the code you just wrote. What is the most likely source of bugs? What edge cases did you not handle?" The answers are almost always useful.
What the Adobe Project Actually Means
This is the part most news coverage gets wrong.
The Adobe project was not a novelty. It was evidence of something that was already true: a frontier model can rebuild mature software products from scratch in a single session. Not a toy version. A working version with the core feature set, written in a modern language, committed to a public repo.
This does not mean all SaaS is dead. Network effects, integrations, data history, support contracts, and user trust are real. But the software code itself is no longer the defensible asset. Anyone with Claude Code and a clear task description can get a working version of most tools in an afternoon.
The practical question this creates for your business:
Before you sign up for a new tool, ask: could Claude Code build a working version of this in an afternoon? If yes, consider whether the paid version is worth the ongoing cost for the integrations and support, or whether a custom build fits your use case better. You now have that option on every evaluation.
The Adobe project did not create this situation. It just made it visible.
The Honest Limits
Claude Code costs tokens. Opus 5.5 costs more per session than Sonnet. A large codebase rebuild session burns significant tokens. Budget before you start a multi-hour build.
It makes mistakes. Especially on large, interconnected codebases where a change in one module ripples into another. The scope guards help. Exploring before editing helps. Reviewing every diff before pushing is not optional. It is the job.
"Rebuild any SaaS in an afternoon" has a footnote. The Adobe project produced a functional rebuild, not a production-ready product. There is a real gap between "it works" and "it handles 10,000 users, their data, their payments, and their edge cases." That gap matters if you are building for real customers. Know which one you need before you start.
The model has a context limit. Very large codebases eventually exceed what Claude Code can hold in a single session. The phase-based approach handles this. Do not try to load an entire enterprise codebase into one session.
One Build to Run This Week
Pick one tool in your stack you pay more than $50 a month for. Open Claude Code. Ask it:
"What would it take to build a basic working version of [tool name] from scratch? Estimate the scope, the tech stack you would use, and how long it would take."
You are not committing to building it. You are getting the data to make a real decision about the subscription. That answer changes how you evaluate every renewal going forward.
Run that prompt before Friday. The guide PDF below covers everything this article covers, formatted for offline reading and sharing with your team.