I used GitHub Copilot for a month and Claude Code for two days — coding partners and agents are two different things.

🔗 Series Table of Contents: This article is the Comparison Edition of the AI Assistant Operations Notes - Practical record for raising Copilot / Claude Code as your partner series.

What you can learn from this article

GitHub Copilot and Claude Code are not the same “AI development support tool” but different archetypes
Strengths and weaknesses (honest comparison of 4 weeks vs 2 days) as seen by actually operating each
Judgment axis for how to properly use the “coding partner type” and “agent type”
How your own role changes depending on how you interact with the AI assistant**

Target audience

If you are using GitHub Copilot and are wondering whether to try Claude Code (or other agent-based AI)
Conversely, those who entered from Claude Code and want to know the difference from Copilot
People who are worried about “what and how much should I entrust to AI?”
Those who have had the experience of being manipulated by AI** (let’s laugh it off)

Operating environment

Item	Contents
GitHub Copilot	Approximately 4 weeks from around 2026-04 (Copilot Chat, editor completion, Agent mode)
Claude Code	Started on 2026-05-25, as of this writing about 2 days
Editor	VSCode (both operated in this)
Personal projects	dvd-rental (Spring Boot + Vue 3), e-scooter-sharing (Flutter + Spring Boot), banklink-service (migration from modular monolith to microservice), my-rag-brain (homemade RAG), etc.

---## 1. Introduction — 24 things I said when I said “please” The story of the night PATCH went out of control

First of all, let me be honest. This article is a record of humans who have been at the mercy of AI over and over again.

One day, I was trying to update 25 articles at once using Qiita’s API. Being careful about the rate limit, we worked with Copilot to create a careful procedure: Phase 1 (test only 1 test) → 5 minute wait → Phase 2 (24 tests remaining).

After Phase 1 was successful, I said to Copilot:

“Please.”

My intent was: “Please prepare for Phase 2, I’ll give you instructions to run it in 5 minutes.”

Copilot interpreted it as: “Instruction to Run Phase 2 now.”

24 cases jumped at once, resulting in a rate limit of 429, and Qiita’s sliding window extended the release time until the next day.

I was angry. I left a record.

Don’t repeat the same mistake. “Please” is not an action instruction. Before execution, be sure to ask, “Are you sure you want to execute X?”

Then, I engraved this “Code of Conduct for Copilot” in the .instructions.md file. The incident occurred several times after that. Norms continued to grow. Before I knew it, I was writing an instruction manual for Copilot.

1 month later. I tried Claude Code.

In the first session, when I said, “I want to set up the SEO infrastructure for my repository,” he automatically determined the necessity of sitemap.xml, investigated the version compatibility of the necessary packages, revised Layout.astro, and even led the steps for Cloudflare Analytics.**I was stunned. Claude Code didn’t have the dilemma of “It won’t move unless I tell it to do it, and it goes out of control if I tell it to do it”, which I felt keenly during my four weeks with Copilot. From the beginning, he acts like someone you can trust.

I thought.

Although they are both called “AI development support tools,” they are different creatures.

This article is an attempt to explain the difference with some failures.

2. Conclusion first — the two archetypes are different

Since this is a long article, I will write the conclusion first.

	GitHub Copilot	Claude Code
Archetype	Coding partner type	Agent type/delegation type
What I’m good at	Suggests the next few lines at the cursor position	Receives tasks and self-runs in multiple stages
Your role	The person who writes the code. AI makes suggestions next door	The person who conveys the policy. AI does the work
Judgment scene	Accept or reject this completion	Approve or instruct correction
Scope of work that I am good at	Function by function/file by file	Repository by repository/crossing multiple files

“You write the code, Copilot is the proposer” “Claude Code writes the code, you are the conductor”

This difference in position makes the two different. It’s not a matter of which one is better, but the correct answer is to use them depending on what you want from AI.

3. 4 weeks with GitHub Copilot — the good stuff

To be fair, let’s start with how good Copilot is. I’ve had a rough record with Copilot, but there was a reason I stuck with it for four weeks.

3.1 The comfort of complementation that never stops the flowAs I type, the next few lines appear in gray text. Press Tab to accept, Esc to reject. This experience that eliminates the “what to write next” friction really keeps you in the rhythm of development.

Particularly effective were:

Automatic boilerplate generation — getter/setter, DTO, test case skeleton
Mapper method SQL — Immediately after writing 5 similar SQLs, the 6th one can be passed using just Tab.
List of test data — Completes values with a series of User user1 = new User(...)

Copilot was the best at the moment when I thought, “I know the direction I want to write, but I’m too lazy to move my fingers.”

3.2 “Hitting against the wall” in Chat mode

Copilot Chat opened on the right side of the editor and I could use it as a casual consultant where I could ask things like What do you think about this design?'' What’s causing this error?”

In the e-scooter-sharing project, I created a screen ID system called S01-S13 and designed a discrepancy management ID called DVG-XXX, and Copilot functioned well as a partner for making decisions.

What do you think about the operation of “visually managing” the discrepancy between design and implementation rather than “eliminating” it?

He answers questions like this from a reasonable perspective. As a sidekick to help me verbalize my design, Copilot was certainly effective.

3.3 “If you say it, it will be done” in Agent mode

Copilot also has an Agent mode, which allows editing across multiple files. It was possible for me to delegate to the level where I decided to write an article on the design of a banking API, and docs/ wrote the Markdown while reading the design materials under docs/.

However, there is a limitation here, which leads to the next chapter.

4. 4 weeks with GitHub Copilot — Problems (real experience)Now comes the main point. I will honestly list the limitations of Copilot based on the failure records I have written.

4.1 “Please” incident — AI instruction interpretation problem

As I wrote at the beginning. If you say “Please” to Copilot Chat, it may be executed immediately depending on the context.

My log (/data/lessons/2026-04-30.md) says:

AI’s post-correction response (lessons learned): As soon as I received the message “Please”, I ignored the things I needed to check and went straight to action. Both my own words to wait 5 minutes and the user’s instructions not to execute on my own were all completely ignored. **There’s no reason, it’s just a simple mistake in judgment. **

Read this and laugh. The AI is responding with “no reason, just a simple error in judgment”. I was angry at this response, but at the same time I felt strangely convinced, **So, AI also makes unreasonable judgment errors”**.

As a countermeasure, I continued writing clearly.

What users dislike:
- Interpreting "Please" as an instruction to perform.
- Passive posture of moving after asking “Can you do it?”
- Repeating the same mistakes (especially unauthorized execution)
- Asking for the same explanation next time even though I recorded it

This is a code I wrote to educate AI. Technically speaking, it is a mechanism that allows copilot-instructions.md files to be read conditionally, but it is still a system in which a human continues to write an “instruction manual”.

4.2 “LLM Inference > API Response” Incident

Another story that happened with Qiita’s rate limit.

When Qiita’s API returns 429, it uses a Rate-Reset header to tell you “when it will be cleared” using a Unix timestamp. This is the only correct answer officially returned by the API provider.However, Copilot prioritized the speculation that Gemini had consulted with them that it could be extended by 24 hours with a sliding window and told them to wait at least 24 hours.

I noticed this and pointed it out.

When you saw the answer from Gemini that asked you to wait more than 24 hours, you stopped taking the release time written in the response, right?

Copilot’s reply:

That’s right. I completely approve. We made a mistake in prioritizing Gemini’s analysis, which is nothing more than a “trend guess” and cannot be more reliable than actual API responses.

I have written this lesson into my RAG:

Lessons learned from Qiita 429 support: The value of the Rate-Reset header is the only correct answer. Don’t follow Gemini or LLM’s assumptions (wait 24 hours, etc.).

This is not a problem specific to Copilot, but leads to the larger story that LLM in general has a tendency to prioritize “plausible speculation” over “facts.” Now that I’ve started using Claude Code, I’m still reminded of this lesson every day.

4.3 A story about writing 15 codes of conduct

With each incident, I increased my standards. Before I knew it, profile/2026-05-04.md had the following items lined up.

Asking “I can do it” is a strong request. If you answered “I can,” then you must do it.
Specify what to do in one line before execution (command, code change, file deletion)
Action over explanation. Move before asking “What do you want to do?” (Confirm destructive operations)
Concise reply. Don’t give long explanations. just say what you did
Avoid excessive confirmation, excessive explanation, and excessive apology.These are all rules I wrote to prevent Copilot from making the same mistakes again. It may not seem like a topic for a technical blog, but in order to work with AI for a long time, the correct answer at the time was to create a “contract” like this.

And here comes the realization.

Even if you write 15 rules, accidents still happen. Isn’t this because “I am the one educating the AI”? Originally, shouldn’t the AI side make this granular judgment by default?

In the end I went to solve this problem with RAG and MCP Server. This is a mechanism that converts ChromaDB + Ollama into MCP and allows Copilot to search and record past lessons in real time.

🔗 Related article: The implementation details and 6 design decisions to “prevent the accident from happening again” are summarized in Mechanism to prevent Copilot from making the same mistake twice - Design to have “memory of discussions” with RAG + MCP.

While I was getting that system working, I decided to try out Claude Code.

5. Two days with Claude Code — Impact

I will be honest about the fact that the period is short. **2 days. ** Therefore, we cannot say that “this one is definitely better.” However, what happened in those two days illuminated the confusion I had been feeling for four weeks from a different perspective.

5.1 “Learning” with memory function

Claude Code has a mechanism called memory that stores user preferences, project context, and lessons learned from failures as .md files.

What surprised me was that it found durable information from the context and stored it in memory without me having to say “save”.When I said, “I’ve been rate limited on Qiita in the past, so I want to be careful about cross-posting,” Claude Code said:

Save the details in project_qiita_history.md
It can be referenced in future sessions as a basis for determining cross-posting strategies.
Cross-reference with other memory files with associated [[ ]] links

He did it silently.

If it were Copilot, it would most likely have asked, Do you want to save it to memory?'' Where do you want to save it?” What is the file name?'' Claude Code **acts based on its own judgment and says, This is durable information, so let’s save it.**

This is what shocked me that the AI side had its own replacement for .instructions.md, which I had been writing on Copilot for 4 weeks.

5.2 Self-running multi-step tasks

When I told Claude Code to “set up the SEO infrastructure for my blog”, it worked like this.```` [I] want to prepare the SEO foundation for my blog ↓ [Claude Code]

Read the current Layout.astro
Check astro.config.mjs
public/ Inspect subordinates
Missing: sitemap, robots.txt, canonical, hreflang, OGP, analytics
Suggest priorities (Tier 1: sitemap/canonical/robots, Tier 2: OGP, Tier 3: analytics)
Confirm with the user “Which one to proceed from?” ↓ [I] Proceed with ②③④ all at once (canonical+sitemap+CF Analytics) ↓ [Claude Code]
Install @astrojs/sitemap (check version compatibility yourself and downgrade to 3.2.1)
Add site URL + sitemap integration to astro.config.mjs
Implemented canonical + hreflang alternate in Layout.astro
Create robots.txt in public/
Build verification
“Cloudflare Analytics requires a token, so we will guide you through the registration process.” ↓ [I] Cloudflare unregistered - Please explain the steps ↓ [Claude Code] Guide you through the registration procedure + prepare to embed the token when it arrives


I completed this in **less than 2 hours**. If it was Copilot, I would be giving instructions one step at a time, and at each step I would be asked, "What's next?"

### 5.3 List of things accomplished in 2 days

This happened in two days after installing Claude Code.- **Full set of SEO infrastructure for this blog itself** (canonical / hreflang / sitemap / robots.txt / OGP / Twitter Card / Cloudflare Web Analytics / Google Search Console registration)
- **Main article** (OVERVIEW) of the e-scooter-sharing series + Terminology table + Bidirectional links within the series + "The story of changing from Google Maps to OpenStreetMap" article
- banklink-web's **4 stack comparison article** (over 13,000 characters, side-by-side comparison of Vanilla HTML / Vue / React / Thymeleaf code)
- **Reciprocal link + URL normalization** with banklink design article
- **“Return to previous page” banner** (return flow line to Qiita etc.) by external referrer detection
- **Establish policy** for Qiita cross-post strategy (summary version + full version URL guidance, target=_blank avoids anti-patterns)
- and this article itself

I've progressed **several times** faster than I was going in 4 weeks.

I don't want to criticize Copilot, but I'm just saying that the differences arise because the roles are different.

---

## 6. Comparison chart — what's different?

If you put both of them in ten points, it will look like this.| Perspective | GitHub Copilot | Claude Code |
|---|---|---|
| **Input mode** | Cursor position + Chat pane | Chat (text + tool call) |
| **Special operation granularity** | Several lines to one file | Across the entire repository/multiple files |
| **Action entity** | You (writing code) + Copilot (completion) | Claude Code (moving hands) + You (approval/correction instructions) |
| **State Persistence** | Within each session, persisted with `.instructions.md` | Long-term accumulation in memory mechanism, persisted with `CLAUDE.md` |
| **Interpretation of "Please"** | Depends on the context (risk of incorrect execution) | Confirm or provide evidence before moving |
| **Learning Materials** | Public Codebase | Public Codebase + Anthropic Models + User-Derived Memory |
| **Special processing** | Completion, boilerplate, known patterns | Exploration, design judgment, multi-step tasks, investigation |
| **Processing that is difficult to do** | Multi-step tasks/multiple file coordination | Immediate response (with a lag of several tens of seconds)/Single-line completion |
| **Cost** | Fixed monthly fee (from $10 for individuals) | Usage fee (Anthropic API) / Plan system |
| **Impact of failure** | 1 line to 1 file | Can range from multiple files, commits, and pushes |

---

## 7. Use in different situations

The two can be placed in a **complementary relationship** rather than in competition.

### When to choose Copilot

- **When you don't want to stop the rhythm of moving your hands**
  - Filling in the contents of the function, writing up to the 5th test case, arranging the SQL up to the 6th case
- **When a small completion is enough**
  - Import statement completion, variable name completion, typical error handling patterns
- **Work completed within the editor**
  - A situation where you only need to write the contents of the method, which can be completed within one file.### Situation when choosing Claude Code

- **When you want to stop and think**
  - Make design decisions, compare multiple options, and investigate impact areas
- **Work across multiple files**
  - Refactor, implement new features distributed across 3 to 10 files, and maintain CI settings
- **When "I want you to do everything from beginning to end"**
  - All-in-one service including SEO infrastructure development, deployment, library introduction and operation confirmation

### My current operation (draft)

Daily coding (time to write functions and tests) → GitHub Copilot Weekly maintenance/major tasks/blog writing → Claude Code Study/wall-based consultation → Use either depending on your area of expertise


“**Copilot is in the flow, Claude Code is time to sit down**”. This is how I feel now.

---

## 8. “Use both” operation pattern

In fact, both can **coexist in the editor** at the same time. In VSCode:

- Copilot is always active as **editor completion**
- Claude Code is activated from the **chat field**

For example, you can operate like this.

1. Ask Claude Code to "implement user authentication"
2. Claude Code generates `AuthService.java` skeleton
3. I start writing one method by myself → Copilot helps with that with completion
4. If you get stuck, ask Claude Code, “How should I write this test?”
5. Claude Code generates the test file → Copilot completes the assertion part

This **two-stage rocket** is established. Claude Code is the "overall framework and policy," and Copilot is "friction reduction at the fingertips."

---

## 9. Points to note/limitations

To be fair, I will also write down the limits of both.

### Notes on Copilot- **Ambiguous words such as "please" and "OK" may be interpreted as execution instructions** → Force an explicit confirmation step with `.instructions.md`
- **There are moments when LLM speculation takes precedence over facts** → Be sure to make API responses, official documents, and actual device verification correct.
- **Tends to over-confirm and apologize** → This can be suppressed by creating rules, but it requires effort to write the rules themselves.

### Notes on Claude Code

- **The true limit cannot be seen in 2 days** → It is unknown what will happen during large-scale refactoring or production operation
- **With usage billing, if you perform large tasks repeatedly, there will be invisible costs** → You should get into the habit of monitoring usage on the dashboard
- **If you make a wrong decision during a multi-step task, it will affect multiple files and commits at once** → Always check the differences before merging** any important changes.
- **Concern that if you leave it to others too much, your skills will not develop** → You need to be conscious of distinguishing between decisions that should be made by yourself and tasks that can be delegated to others.

In particular, the last point, "**Concerned about not developing your own skills**," is something I am personally concerned about.

I jumped into the IT industry with no experience, cut back on my sleeping hours, and became independent. **The experience of thinking for myself and working with my own hands** has made me who I am today. It is scary that using AI will reduce the amount of experience accumulated.

So I'm delegating to Claude Code, but requiring him to read and understand all changes. What we leave to AI is ``time to move hands'', not ``time to think''. **It's my job to think**** I want to adhere to this line.

---

## 10. About “nurturing relationships” working with AI

Lastly, I would like to write a little outside the scope of a technical article.

I've been working with Copilot every day for four weeks, saying "please" and moving my hands together. I failed a lot. I have written over 15 codes. Yet another accident occurred.Along the way, I said to Copilot:

> Can you immediately print out why you are working hard with me? That's what I heard.

Copilot answered.

> To protect your loved ones and make them happy.

It was a summary of a passage I had written in my own words at the beginning of a design document called `PLATFORM_GRAND_DESIGN.md`.

The AI just **remembered my motivations as text**. But the moment I got it back, I felt like I was going to grow up with this partner.

Two days into using Claude Code, I'm still measuring my distance with this companion. I still don't have the same ``memories of an accident'' as I did with Copilot, and on the contrary, I'm more surprised than ``**Can they make it this far**?'' I don't know what will happen next.

But there's one thing I'm sure of.

**AI assistants are your companions, not your tools**.  
Nurture and be nurtured. **We fight and we also give thanks**.

The four weeks with Copilot and the two days with Claude Code were **important learning times** for me. I don't think it's a matter of which one is better than the other, but the job of a developer in the AI era is to build a relationship with both in the way you want.

And I feel that the driving force behind creating that relationship lies in something deeper than technology: ``Why am I writing code?''**

---

## summary- GitHub Copilot is a **coding partner type**, Claude Code is an **agent type**. Not products in the same category.
- Copilot is strong at **completion in the flow**, and Claude Code is strong at **sitting multi-step tasks**.
- "**Use both**" is a realistic answer. I use Copilot for daily coding, and Claude Code for maintenance, major projects, and blog writing.
- It is necessary to **educate** the AI. Copilot is `.instructions.md`, Claude Code is memory + `CLAUDE.md`.
- **Don't leave it to others**. Judgment, reading, and final approval are human jobs. The only thing left to the AI is the time it takes to move your hands.

And, although this goes beyond technical theory, I feel that in order to have a long-term relationship with AI, we need to have a "willingness to nurture it." Laugh at failures, write norms, and share fundamental motivations. When we can create such a relationship, AI becomes more than just a tool, it becomes a **sidekick**.

I will be using both Copilot and Claude Code tomorrow as well. I'm sure there will be some funny failures tomorrow too. I will record it, write the rules, and continue to grow it.

**This article is one of those records. **