Earning $1.6M Solo: The Advanced Claude Code Workflow Used by Global Top Creators

Using AI Not Just to Write Code, But as an Employee Running a One-Person Company 24/7

When people hear "earning money with AI," most imagine the same things:

• Having ChatGPT write blog posts.
• Mass-producing images with AI.
• Posting AI-generated videos to TikTok.
• Having AI write programs to mass-produce apps.

However, there are few cases where you can earn significantly using these methods alone.

This is because you are merely increasing "work volume" using AI.

Even if you increase the number of articles from 10 to 100, if there are no readers, revenue won't increase. Even if you increase the number of apps from 1 to 10, if you aren't solving customer problems, no one will pay.

Truly powerful people in the AI era don't use AI as a content manufacturing machine.

They use it to make the company itself smaller.

They don't hire developers.

They don't increase customer support.

They don't hold meetings.

They don't pass specifications between humans.

They don't hand over code through multiple stages from local to production environments.

When a request arrives from a customer, the AI reads the code, fixes it, tests it, and makes it ready for the user to touch within minutes.

An extreme example of this is solo developer Pieter Levels.

His use of Claude Code can be summarized in one sentence:

Use Claude Code not as a "convenient coding assistant," but as an employee living inside the server.

In this article, we will break down what Pieter is doing and translate it into a form that Japanese solo developers and small business owners can replicate.

Who is Pieter Levels?

Pieter Levels is a solo developer who has launched multiple internet services such as Nomad List, Remote OK, Photo AI, and Interior AI.

One of the reasons he became widely known was his project to "build 12 startups in 12 months." Instead of raising large funds to build an organization, he followed a style of releasing services quickly and nurturing only those that got a reaction.

One of his current flagship services is Photo AI, an AI photo generation service.

Users upload their photos, and the service creates an AI model of that person to generate studio-style photos, profile pictures, fashion photos, travel photos, videos, and more. The Photo AI official site states that over 30 million photos have been generated to date.

In March 2024, Pieter disclosed the following figures for Photo AI:

Even more surprising is his revelation that the core of the service runs on a single, massive PHP file of about 40,870 lines.

A typical engineer might frown upon hearing this.

"Such a huge file is unmaintainable."

"It should be split into microservices."

"A more modern framework should be used."

But revenue is not paid for the beauty of the code.

If you are delivering the results users want and maintaining that state, the technical configuration doesn't need to follow the textbook.

Pieter's strength isn't knowing more cutting-edge technology than anyone else.

It's his thoroughness in discarding complexity that doesn't lead to revenue.

Strictly Speaking, He Didn't Earn "Only with AI"

Don't misunderstand this part.

Pieter didn't just start touching Claude Code one day and suddenly earn $1.6M a year with AI alone.

He has years of development experience. He has internet fame and followers to whom he can market his products. He has the judgment to choose markets, the ability to set prices, and the experience to read user reactions.

AI didn't create everything from zero.

AI amplified the development power, judgment, and marketing power he already possessed.

This difference is huge.

Using AI doesn't make experience unnecessary. Rather, as implementation speed increases due to AI, the value of judging "what to build," "who to sell to," and "what not to build" becomes higher.

Therefore, the true theme of this article isn't "what magic prompt to put into Claude Code to earn millions."

It is how to create a system where one person moves at the speed of a company using Claude Code.

Method 1

Let Claude Code Live on a VPS, Not a Laptop

The most distinctive feature of Pieter's operation is that he runs Claude Code on the VPS where the service is running, rather than on a local laptop.

According to him, for about a year, he has done almost all coding with Claude Code on a VPS. He can continue processing even after closing his laptop, it doesn't consume battery, and he can take over work from another terminal or smartphone. Since new services can be started from a state already on the server, they can be taken straight to public release.

A typical development flow looks like this:

1. Plan.
2. Write code in a local environment.
3. Test locally.
4. Push to GitHub.
5. CI runs.
6. Reflect in a staging environment.
7. Confirm and deploy to the production environment.

In large organizations, this process is necessary. Since dozens of engineers touch the same system, boundaries to prevent accidents are essential.

But what happens when you bring large-company processes into a small service run by one person?

The fix itself takes 3 minutes, but it takes 20 minutes to go live.

Small hassles accumulate, and the judgment that "this change can wait until later" increases. Even if a request comes from a customer, the fix is postponed to the next day or next week.

Pieter made this waiting time extremely short.

Previously, it took about 1 minute to test locally and auto-deploy via GitHub. By switching to pushing directly to the server, it took about 3 seconds, and now he is moving toward having Claude Code change the code directly on the server. While he mentions that the site only went down about twice in 12 months for about 10 seconds each, he also clearly states that a large company would use a staging environment.

The point to emulate here isn't "everyone should edit the production environment directly."

What should be emulated is placing the AI where it can continue working.

As long as you run Claude Code on your own computer, the work stops when you close the laptop. It stops if the connection is lost. If you move to another terminal, you have to explain the situation all over again.

By running it in a persistent session on a VPS, the AI can stay right next to the project.

This isn't just a difference in environment setup.

It's the idea of decoupling the time AI can work from human operating hours, rather than just increasing "time spent using AI."

Method 2

Give Each Product Its Own Persistent Session

Pieter uses Termius to connect to the VPS and prepares connection profiles for each service.

Upon connecting, he moves to that service's directory and enters the corresponding tmux session. In each session, Claude Code remains open, allowing him to return to the same work from a laptop or smartphone. He even had Claude Code create the shell functions to make connecting and returning to tmux easy.

The important part of this system isn't that terminal operations look cool.

It's that each product has its own dedicated workroom.

• The Photo AI room has Photo AI code and Claude Code.
• The Nomad List room has Nomad List code and Claude Code.
• The Remote OK room has Remote OK code and Claude Code.

When a human switches products, they just need to enter that room.

With general chat-type AI, you need to explain things every time you start a conversation.

"This is this kind of service."

"I implemented up to here last time."

"Please don't change this file."

"Run tests with this command."

That explanation cost robs AI utilization of its speed.

On the other hand, if you keep Claude Code running within the project directory, the AI has direct access to code, config files, tests, and history. Even without a human explaining from zero, it can investigate "what the current state of this product is."

Anthropic's official documentation also explains Claude Code not just as a tool that returns code suggestions, but as an agentic tool that proceeds with reading files, executing commands, changing code, investigating, planning, and implementing.

In other words, to draw out the strengths of Claude Code, you need to have it work in a place where it can access the entire product, rather than pasting code snippets into a chat box every time.

Method 3

Pass the "Completion State," Not "Write Code"

People who don't get results even with Claude Code are either too detailed or too vague in their instructions.

For example, a request like this:

Please improve the login screen.

With this, it's unclear what constitutes an improvement.

• Change the design?
• Change the error display?
• Increase login speed?
• Add Google login?
• Want to reduce the bounce rate?

Conversely, instructing every single line of code is also inefficient.

Add a function to line 35 of this file, then change this variable name...

In this case, you are only using Claude Code as a keyboard with a faster input speed than yourself.

What you should pass is not the work procedure, but the completion conditions.

In practice, a format like this is easy to use:

Objective:

Reduce drop-offs due to login errors.

Current State:

Whether it's a wrong password or a connection error, the same "Login failed" is displayed.

Scope of Change:

Login screen, authentication API, related tests.

Completion Conditions:

• Different messages are displayed for input errors vs. connection failures.
• Do not leak the existence of email addresses to the outside.
• Do not break existing Google login.
• Layout does not break on smartphone displays.
• All related tests pass.

Prohibitions:

• Do not change the database structure.
• Do not add new authentication libraries.

Post-work:

• Summarize changed files.
• Show executed tests.
• Report remaining risks.

In this format, Claude Code can investigate the codebase, find the locations to change itself, and think of implementation methods.

The human role shifts from "how to write" to "what state will provide value."

Here, management and development connect.

To write good completion conditions, you must understand what customers are struggling with. A person who looks at customer behavior, reasons for payment, and reasons for churn can give Claude Code more valuable work than someone who only looks at technology.

What's important in the AI era isn't prompt vocabulary.

It's the power to define the completion state.

Method 4

Make CLAUDE.md the "One-Person Company Operations Manual"

Claude Code has a mechanism to save project-specific instructions in CLAUDE.md.

Official documentation explains that CLAUDE.md is read at the start of a conversation, allowing you to list build and test commands, coding conventions, and work rules. However, it is recommended to keep it short and specific, not a long manual, and not to write things that can be understood by reading the code.

Most people only write indentation widths or variable naming rules here.

But in a one-person company, what's truly important isn't code style, but business priorities.

For example, you can write:

Product goal

• This service is for sole proprietors to create product photos within 10 minutes.
• Prioritize speed to first generation over the number of features.
• For changes that increase free user usage, always check the impact on cost price.

Architecture

• Uses PHP, JavaScript, PostgreSQL.
• Do not add new frameworks without explicit permission.
• Do not increase dependencies if it can be solved with existing mechanisms.

Workflow

• Read related code and tests before changing.
• For large changes, present a plan before implementation.
• After changes, perform tests, static analysis, and check major screens.
• Do not solve failed tests by deleting them.

Safety

• Do not delete production data.
• Attach rollback procedures to database changes.
• Do not output API keys or personal information to logs.
• Handle billing, authentication, and deletion functions with extreme caution.

Definition of done

• Can explain changes from the user's perspective.
• Report test results.
• List changed files.
• Clearly state known risks and unaddressed items.

Just having this eliminates the need to repeat the same cautions every time.

Even more important is how to handle it when Claude Code fails.

Instead of just getting angry that "it made the same mistake again," add a recurrence prevention rule to CLAUDE.md.

If it changed a production config file, write "Do not change config files without explicit permission."

If it deleted an important validation to pass a test, write "Deleting failed tests is prohibited."

If it formatted unrelated files and the diff became huge, write "Do not perform refactoring unrelated to the request."

Anthropic also states that recurring mistakes or things explained multiple times are signs to add to permanent instructions.

In other words, CLAUDE.md is not just a config file for AI.

It is a database of failures and judgments accumulated in a one-person company.

In companies that hire employees, knowledge is accumulated in training materials or internal Wikis.

In a one-person company, you have Claude Code read it.

Method 5

Reduce Approval Work, Increase Guardrails Instead

Pieter uses a mode that significantly omits permission checks for Claude Code, working at high speed on the server.

He states that since switching to this operation, development speed has skyrocketed, his task board became empty for the first time, and he achieved about 10 times the usual output. He progressed through changes across multiple products, including authentication and security improvements, image features, video/audio features, 3D viewers, newsletters, chatbots, and ebook generation, in a short period.

However, copying this part exactly is dangerous.

Claude Code's official documentation explicitly states that operations equivalent to bypassPermissions should only be used when there is an external safety boundary, such as an isolated container or virtual machine. This is because the moment you omit confirmation, the last line of defense is only the isolation of the execution environment.

If a Japanese solo developer were to adopt this, instead of replicating Pieter's operation exactly, it's better to translate it as follows:

Plan Mode for the Investigation Phase

First, have it investigate related files, impact scope, implementation policy, and risks without letting it change code.

Especially for parts with high accident impact like billing, authentication, data deletion, and email delivery, do not let it implement immediately.

Automate Implementation in a Staging Environment

Prepare a staging environment with a configuration similar to production and have Claude Code proceed with changes and tests there.

Instead of approving every command every time, separate operations to allow and operations to deny in advance.

Official documentation provides multiple permission modes like acceptEdits to allow changes, auto to automatically judge safety, and plan to only create plans. You can also set allow, ask, and deny on a per-command basis.

Leave Only One Human Gateway for Production Reflection

• Tests passed.
• Screen confirmation finished.
• Diff was within the expected range.
• There is a rollback method.

Once this state is reached, a human permits the production reflection.

What's important isn't for a human to write every line of code.

It's to create a structure that can be reverted when broken, with the human handling only the final irreversible judgments.

Method 6

Prioritize Testing and Rollbacks Over Code Reviews

When AI starts writing massive amounts of code, the method of a human checking everything line by line reaches its limit.

Even if code is generated at 10x speed, if review takes 10x longer, productivity won't increase.

Therefore, what becomes necessary is changing where trust is placed.

Don't believe that "Claude must have written correct code."

Trust the system that:

• "If it's wrong, the tests will fail."
• "Major user operations can be automatically confirmed."
• "If there's a problem, it can be immediately reverted to the previous state."

Pieter himself prioritizes a feedback loop of preparing tests and quickly confirming in production over checking everything in detail. He also explains that the server has multiple backups combining onsite and offsite.

In safe Claude Code operation, create at least these four first:

1. Automated tests for major functions.
2. Operation confirmation before production.
3. Monitoring to detect errors and revenue anomalies.
4. Rollback that can return to the previous state in minutes.

Using Claude Code's Hooks, you can also automate processes such as executing tests or formatters after file changes, or inserting inspections before specific operations. Hooks are an official feature to execute shell commands, HTTP processing, LLM judgment, etc., at specific lifecycles of Claude Code.

For example, automatically execute the following flow after a change:

Code change

↓

Automated test

↓

Static analysis

↓

Operation confirmation of major pages

↓

Summary of diff

↓

Stop production reflection if there is a problem

Through this, the human job changes from "looking at everything" to "looking only at anomalies."

People who earn big alone aren't just doing work fast.

They are reducing the work that requires confirmation itself.

Method 7

Make Customer Requests Directly into Claude Code's Work Queue

In the one-person company configuration Pieter has made public, he combines a feedback board to collect user requests, a Stripe billing management screen for customers, a refund function users can operate themselves, and automated processing using the ChatGPT API.

The ideal form he shows is "1 founder, 0 humans," a model where he handles marketing, development, and design, and automates everything else as much as possible.

Here, Claude Code isn't used just to create new features.

It becomes a device to convert customer voices into improvements that lead to revenue.

For example, a flow like this:

User posts a request

↓

Classify similar requests

↓

Check impact on churn rate and billing rate

↓

Select one high-value item

↓

Claude Code investigates impact scope

↓

Implementation and testing

↓

Notify user of improvement

When you create this system, the meaning of task management changes.

In many companies, after receiving a request, they hold meetings, write specs, decide on a person in charge, put it into a sprint, and finally go public weeks later.

In a one-person company, there's a possibility of releasing it that same day.

What a small company can win against a large company in isn't the number of features.

It's the time it takes for customer voices to be reflected in the product.

If you've introduced Claude Code but humans are still breaking down tasks into detail, copy-pasting code, and specifying change locations one by one, you aren't utilizing the speed of AI.

Pass the customer problem and completion conditions, and let Claude Code itself investigate the codebase.

This is the difference between using it as a chatbot and using it as an employee.

Method 8

Daringly Avoid Complicating the Technical Configuration

The fact that the core of Photo AI is a single PHP file exceeding 40,000 lines doesn't mean all developers should create huge files.

Rather, it's dangerous to mimic the superficial form.

What's important for Pieter isn't that it's PHP or a huge file.

What's important is thought to be keeping the system within a range where he and Claude Code can grasp the whole.

This is an interpretation from public information, but if you split a product into too many small services, every change will span multiple repositories, APIs, authentication methods, and deployment procedures.

Systems complex for humans are also complex for AI.

• More files to load into context.
• Investigation of where to change takes time.
• Inconsistencies occur by updating only one side.
• Test scope expands.
• Identifying causes during failures becomes difficult.

Just because you have Claude Code doesn't mean you can manage an infinitely complex technical configuration.

AI lowers the cost of complexity but doesn't make it zero.

So when introducing a new library, new service, new database, or new framework, think like this:

Does this technology increase the value the customer receives? Or is it just for the developer's technical satisfaction?

A person who created a product with an annual turnover of 200 million JPY didn't necessarily choose the most modern configuration.

This is an important fact for many solo developers.

Method 9

Have Claude Code Create "Company Automation," Not Just "Development"

Many people using AI coding tools only think about implementing product features.

However, what's necessary to earn big alone isn't just making the product.

• Responding to inquiries.
• Detecting fraudulent use.
• Changing billing information.
• Refunds.
• Cancellations.
• Content review.
• Failure notifications.
• Regular reports.
• Revenue aggregation.
• Guidance to customers.

As a business grows, these operational tasks increase.

If revenue doubles, inquiries also double, and if you need twice the manpower, a one-person company cannot be maintained.

In the configuration Pieter has made public, he reduces the points where humans intervene through Stripe customer features, self-service management screens, automated refunds, and worker scripts using AI APIs.

The things you should have Claude Code make aren't just new flashy features.

It's code that eliminates "work you spend 30 minutes on every week."

For example, if you check revenue every morning and write it to Slack, create an automated report.

If there are many inquiries for the same question, improve the management screen or help page.

If you operate the management screen every time there's a refund request, create conditional self-refunds.

If you are visually checking for fraudulent use, detect outliers and send only cases requiring human judgment.

Each one is a small automation, but they add up to change the company's fixed costs.

Create features that erase your own work as much as features that increase revenue.

This is the Claude Code utilization method for leaving profit alone.

Method 10

Make Claude Code a Background Worker

Claude Code isn't just for use while looking at an interaction screen.

Officially, non-interactive execution using claude -p, execution with limited permitted tools, structured output, and session continuation are provided. It is also intended to be called from CI or scripts and incorporated into background processing.

Using this, you can generate work without a human starting a conversation.

For example, execute the following processes every night:

1. Check error logs for the last 24 hours.
2. Classify errors thought to have the same cause.
3. Investigate reproduction methods.
4. Create fix proposals.
5. Fix in a staging environment.
6. Execute tests.
7. The next morning, report diffs and risks to a human.

Or, have it analyze inquiries received from users:

1. Classify inquiries by theme.
2. Aggregate count and revenue impact.
3. Extract items that can be solved by product causes.
4. Rank improvement candidates by priority.
5. Create an implementation plan for the top item.

By this point, Claude Code is not "AI that only answers when a human talks to it."

It becomes a staff member who finishes investigations during the night and has judgment materials ready by morning.

However, the more you run it in the background, the more important safety design becomes.

Exclude irreversible operations like deletion, money transfer, billing, mass sending to customers, and changing production data from the scope of automation.

You must consider the degree of freedom given to AI and the damage scope during failure as a set.

The Biggest Secret

Even if You Increase Development Speed with Claude Code, Customers Won't Increase

In Pieter's posts, the most important thing isn't the talk of technology.

He points out that there are many solo developers who have no revenue or traffic while being obsessed with creating complex AI agent environments or "AI development factories." He says they are satisfied with building development environments and putting marketing on the back burner.

Furthermore, he states that as anyone becomes able to make apps with AI, the real challenge becomes distribution—the power to reach customers.

• Can you already reach many people with information?
• Can you spend advertising costs?
• Can you generate UGC?
• Do you have the idea to create a buzz for free?

As development becomes easier, the difference in these distribution capabilities becomes larger.

This is the cruel reality of the AI era.

When you introduce Claude Code, features can be made fast.

However, even if development speed increases 10x, if traffic is zero, revenue is zero.

Rather, the danger is that by increasing the speed at which you can build, you might mass-produce features for which there is no demand.

Every time you add a feature, code volume, tests, failure risks, and inquiry responses increase.

Maintenance items increase even though customers haven't.

Therefore, half of the time born from Claude Code must be used for things other than development.

• Listen to customers.
• Read reviews of competing products.
• Investigate why products aren't being bought.
• Test prices.
• Rewrite sales pages.
• Publish case studies.
• Share the production process on SNS.
• Create mechanisms that make users want to introduce it to others.

The true value of Claude Code isn't shortening the time to write code.

It's reclaiming the time for humans to think about customers and the market.

A 30-Day Plan for Japanese Solo Developers to Replicate

Even if you don't have the same experience, fame, or followers as Pieter, you can adopt the management philosophy.

However, you must not create multiple services from the start.

First, narrow down to one product, one customer, and one problem.

Week 1: Find People Who Will Pay Before Writing Code

What you make in the first week isn't a finished service.

Decide whose problem you will solve, how, and for how much.

Don't broaden the target.

Instead of "AI tools for all companies," narrow it down like "a tool for real estate companies to create property descriptions in 10 minutes."

Talk to potential customers and confirm what methods they are currently using, how many minutes it takes, and how much they are struggling.

Then create a simple sales page.

Don't just have a free registration button; display the price if possible. Put in mechanisms where users actually take action, such as pre-registration, reservations, or small pre-purchases.

If there's no reaction at this stage, the situation won't change even if you have Claude Code make a massive number of features.

Week 2: Provide Only One Value

In the next week, make only the core feature users will pay for.

Postpone login, management screens, detailed profile settings, numerous templates, team features, etc., until they become necessary.

Have Claude Code first investigate the existing configuration and create an implementation plan.

Once the plan is confirmed, have it proceed with implementation and testing in a staging environment.

Things you must include at this stage are access analysis, billing, error monitoring, and an inquiry window.

Products where you can't confirm revenue are not businesses. Products where you can't confirm errors cannot be self-driven.

Week 3: Create an Environment Where Claude Code Doesn't Get Lost

In the third week, rather than increasing new features, arrange the operational foundation.

Write the product's purpose, technical configuration, prohibitions, test methods, and completion conditions in CLAUDE.md.

Prepare one VPS or safe development environment and one persistent session per product.

Ensure that when Claude Code makes a change, tests, static analysis, and operation confirmation of major screens run automatically.

Also confirm backups and rollbacks.

The goal here isn't "to trust AI completely."

It's to ensure that even if AI makes a mistake, the business doesn't suffer a fatal wound.

Week 4: Use the Same Amount of Time for Sales as for Development

In the final week, publish one improvement every day.

However, don't decide on improvement content based on your own whims.

Decide based on user reactions such as inquiries, drop-off points, behavior just before payment, and reasons for cancellation.

• In the morning, select one problem with the largest impact on revenue.
• Request investigation and implementation from Claude Code.
• Publish after testing.
• In the afternoon, inform customers of that improvement.

If you share that you've improved something, that itself becomes marketing.

Rather than saying "I'm developing," showing "I reflected the request that arrived yesterday today" conveys the product's speed and reliability.

The Daily Loop for Running a One-Person Company

After introducing Claude Code, instead of registering a massive number of tasks, run the following loop every day:

Morning: Look at the Numbers

Look at revenue, registration count, paid conversion rate, cancellations, errors, and inquiries.

Start the day from the state of the business, not the code.

Late Morning: Select One Highest-Value Problem

Instead of ten small tasks, select one.

The judgment criterion isn't "is it interesting?" but the impact on revenue, retention rate, and usage success rate.

Midday: Pass Completion Conditions to Claude Code

Have it investigate related code and confirm the plan.

Afterward, have it proceed to implementation, testing, and diff summary.

Humans don't instruct work procedures in detail but convey the correct answer for the customer.

Afternoon: Publish and Reach Customers

It's not over once you publish the improvement.

Inform users who sent the corresponding request. Share the production process on SNS. Reflect it on the sales page. Make it a case study.

Always connect developed items to distribution.

Night: Turn the Day's Failures into Rules

Confirm where Claude Code got lost, where it made unnecessary changes, and what the human explained multiple times.

If necessary, add short rules to CLAUDE.md.

Every day, the AI is optimized for your company bit by bit.

Things You Must Absolutely Not Mimic

Pieter's case is stimulating, but you will fail if you only copy the surface.

Letting It Operate Freely in the Production Environment Suddenly

It is dangerous to skip all permission checks in an environment handling production data, billing, authentication, and notifications to customers.

First, operate in an isolated development or staging environment and limit permitted operations. Official documentation also states that modes omitting permission checks require isolation such as containers or VMs.

Mimicking Only the Huge PHP File

A 40,000-line file didn't generate revenue.

It is the result of Pieter choosing a configuration he can understand and change quickly himself.

The technical configuration should be matched to your product, experience, number of users, and failure risk.

Mass-Developing with AI Without Confirming Demand

When development costs drop, judgment for making things becomes lax.

Don't "make it because it can be made quickly," but "make it because it's a problem for customers who pay."

Before requesting from Claude Code, decide which number that change will improve.

Confusing Revenue with Profit or Personal Income

Monthly revenue of $105,000 and monthly profit of $80,000 are different numbers.

Furthermore, business profit and personal take-home pay are not the same. It changes depending on the handling of taxes, settlement fees, infrastructure costs, AI API costs, refunds, etc.

When looking at large numbers, you need to confirm whether it's "revenue," "gross profit," "operating profit," or "personal income."

Assuming AI Will Correct Business Judgments

Claude Code can investigate codebases, create implementation plans, and execute tests.

However, whether that feature is truly necessary, how much to price it, and which customers to target cannot be understood just by reading code.

The moment you leave market judgment to AI, it becomes the same average product as other AI users.

What's Generating Millions Isn't a Secret Prompt

It's a mistake to look at Pieter Levels' Claude Code utilization and think "I can earn if I use the same prompt."

The secret isn't in the prompt.

• Place Claude Code on a VPS.
• Give each product a persistent session.
• Pass completion conditions.
• Accumulate judgment criteria in CLAUDE.md.
• Prepare for failure with tests and backups.
• Reflect customer requests in the product immediately.
• Automate operational tasks you are repeating.
• Use the freed-up time for marketing.

The strength is combining these as a single system.

The value of Claude Code isn't being able to write code fast.

It's being able to make the following loop extremely short:

Customer is troubled ↓ Understand the cause ↓ Fix ↓ Publish ↓ Measure results

Run a loop that takes weeks in a normal company alone in a day, or in some cases, a few hours.

If this speed accumulates for months, the difference in products becomes huge.

However, AI creates supply, not demand.

• Whose problem are you solving?
• Why do they pay?
• How will you make your existence known?
• Why choose your product over competitors?

Humans must find the answers to these.

In the AI era, "what only overseas geniuses are doing" isn't writing difficult prompts.

It's using AI to erase work itself from the company before AI takes their jobs.

And they are using the time born from that erasure not to write more code, but to understand customers and sell products.

That's why even one person can run a business with an annual turnover of 200 million JPY and an annual profit pace of 160 million JPY.

Claude Code is not a magic tool that makes you earn millions.

However, for those with the right customers, right products, and right sales power, it becomes a device that amplifies one person's judgment to a company scale.