{/* banner prompt: A vivid 3D infographic scene on a clean white background where a stream of jumbled receipts and paper documents flows through a friendly, glowing AI assistant icon and emerges as a single, perfectly organized digital tax return, all rendered in a modern, optimistic style with a palette of bright teal and orange. */}

The first wave of AI anxiety arrived in software development. That makes sense: code is structured, digital and unusually easy for a machine to generate, test and revise. The next wave may be quieter, but just as important. It is arriving in accounting, especially in the part of accounting that looks like collecting documents, classifying transactions and completing familiar forms.

That does not mean accountants disappear. It does mean some accountants' jobs are going to be cut, and many others are going to change.

## The return that used to need a professional

In Australia, individuals have long been allowed to prepare and lodge their own tax returns. The ATO's myTax service is available to people who want to lodge for themselves, with much of the information pre-filled from employers, banks, health funds and other institutions. [The ATO describes myTax as available to individuals and sole traders who want to lodge their own return](https://www.ato.gov.au/api/public/content/0-f9693a0f-35d4-4a60-912a-61913daaac0f).

The permission existed before generative AI. The difficulty was confidence.

Many people could technically do their own return, but did not know what a label meant, which records mattered, or whether an apparently small detail changed the result. Paying an accountant was partly payment for expertise, and partly payment for reassurance.

AI changes that balance. A person can ask, in plain language, what a field means. They can provide a folder of statements and ask for a checklist. They can compare a draft against last year's return, find a missing category, or turn a pile of receipts into a structured record. The work becomes less mysterious and less intimidating.

Nobody knows your own situation better than you do. If you do not know that a particular payment or expense exists, your accountant cannot help you claim or report it. I did not know that income protection premiums could be relevant to my tax return until I looked more closely. An AI assistant that scans an organised list of expenses may be able to flag that kind of possibility, along with questions to take to an accountant. It is not a substitute for checking the rules, but it can help people notice what they would otherwise miss.

Privacy is a legitimate concern. Before sending records to an AI service, taxpayers can anonymise or redact names, addresses, account numbers, tax file numbers and other identifiers, and keep the original documents securely. They should also understand the provider's data-retention and training settings. Anonymisation reduces exposure, but it does not remove the need to use a service they trust or to review what is being uploaded.

That is enough to move a large amount of routine work away from professional firms.

## Single returns are the obvious first target

For a single person with one employer, a bank account and a handful of ordinary deductions, the job is often relatively constrained. There may be judgment involved, but there are fewer relationships between the facts.

AI is particularly useful here because it can explain the process step by step without making the taxpayer search through a dense help page. It can ask the questions a careful preparer would ask:

- Was this expense paid personally?
- Was it reimbursed?
- What percentage was work-related?
- Do you have a receipt or another record?
- Is this income, a deduction, or a capital transaction?

The taxpayer still carries responsibility for the answer. But the barrier to getting to a sensible answer is much lower.

## Families are where the complexity starts to compound

Couples and families are different. A return is no longer an isolated document. One person's taxable income can affect the other person's spouse questions, offsets and eligibility calculations. Children, childcare, family payments, private health cover, super contributions and income tests can all connect the returns.

This is where an AI assistant can be more valuable than a simple tax calculator. It can maintain a shared timeline, remember which person paid an amount, keep a record of carried-forward losses, and show how one figure flows into another return. It can turn “What do I put here?” into “This number comes from Eric's final return; this other number comes from Min's income test.”

That assistance does not make the tax law simple. It makes the complexity navigable.

It also creates a new risk: a fluent answer can still be wrong. AI can confuse taxable income with assessable income, treat a capital loss as an ordinary deduction, or confidently classify a transaction without enough facts. A good system needs source records, explicit assumptions and a final review, not just a polished paragraph.

## What gets cut, and what remains valuable

The most exposed work is repetitive preparation: chasing standard documents, entering data, checking arithmetic, copying figures between related forms and answering the same basic questions. Firms that needed several people for this work may need fewer people, or may redirect them to more clients.

The valuable work moves upward. Accountants will still be needed for business structures, trusts, companies, international income, complicated capital transactions, audits, disputes and situations where the cost of an error is high. They will also be needed when a client does not merely need an answer, but needs someone to take professional responsibility for a judgment.

In other words, AI removes some preparation labour while increasing the premium on interpretation, review and accountability. That is the same pattern already visible in programming: fewer hours spent typing the obvious code, more time spent deciding what should be built and proving that it works.

## The new middle ground

The interesting future is not “everyone fires their accountant” or “AI changes nothing”. It is a much larger middle ground.

Some people will still outsource everything. Some will do everything themselves. Many will prepare a first draft with AI, then pay an accountant for a targeted review. Others will use an accountant once a year and an AI organiser throughout the year to keep records tidy.

That is a meaningful change in the market. The professional relationship becomes less about being the only person who can operate the form, and more about being the person who can recognise the edge of the form.

Accountants' jobs are therefore genuinely being cut by AI, after programmers' jobs began to be reshaped by it. But the deeper story is about access. More people can now participate in their own financial administration, ask better questions and understand the consequences of their choices.

The safest version of that future pairs AI's patience and organisation with human judgment where the facts stop being routine.

*The next post will look at what an AI-assisted tax workflow should record so that convenience does not come at the cost of an audit trail.*


b27c310c4542fa4c713b4e62ebf3b2a02359b47f2dac3142853566bfcb13fbbf

AI is changing Australian tax preparation by making self-managed returns easier, while complex family and business situations still need professional judgment.

AI is already changing programming. Tax and accounting may be next, not because accountants vanish, but because more people can now handle straightforward affairs themselves.

After Programmers, AI Is Coming for Accountants

{/* banner prompt: Of course! Here are three creative and engaging prompts for a banner image, each with a different artistic focus but all reflecting the core idea of the blog post.

---

### Option 1 (Metaphorical & Cinematic)

This prompt focuses on the idea of an AI breaking free from its digital confines to take direct control of a system.

**Prompt:**
> A cinematic digital art masterpiece. On the left side of the frame, a brilliant, glowing AI neural network is trapped inside a transparent, sandboxed cube representing a browser. A powerful, focused beam of light, composed of streaming green `bash` and blue `PowerShell` command-line text, shatters the cube's wall. This beam, representing the Cygwin SSH connection, extends to the right side of the frame, where it elegantly manipulates a complex, holographic 3D model of the Windows operating system. The beam is precisely deleting registry hives, stopping service gears, and cleaning up file system clutter, transforming chaos into order. The overall aesthetic is dark, futuristic, and infused with glowing neon data streams. --ar 16:9

---

### Option 2 (Direct & Illustrative)

This prompt visualizes the conversational aspect and the direct cause-and-effect of the user's request.

**Prompt:**
> A futuristic command center interface. In the foreground, a sleek, floating chat window displays a human's request: `"Uninstall all bloatware and clean the registry."` An AI responds: `"On it. Establishing SSH connection..."`. In the background, a massive, dynamic data visualization of the Windows OS shows the command in action. Streams of code flow from a central SSH terminal icon, targeting and dissolving icons for unwanted programs, while a 3D representation of the Windows Registry is being methodically scanned and cleaned by glowing green cursors. The style is clean, high-tech, and focuses on UI/UX design, with a dark theme and vibrant blue and green highlights. --ar 16:9

---

### Option 3 (Symbolic & Abstract)

This prompt uses symbolism to represent the fusion of two different tech worlds: the open, command-line world and the Windows GUI world.

**Prompt:**
> An abstract digital painting. A stylized, glowing Tux penguin (representing Linux/Cygwin) and a serene, blue AI entity (representing Claude) are working together as one. They are extending their hands, which are made of pure command-line code, through a shimmering portal shaped like the Windows logo. On the other side of the portal, their code-hands are masterfully deconstructing and reassembling Windows components like services, registry keys, and startup items, represented as intricate, glowing geometric shapes. The background is a dark, digital void, emphasizing the powerful and precise nature of the remote management. The lighting is dramatic and symbolic. --ar 16:9

Additional instructions: An AI maid */}

## The Problem with Browser-Based AI Assistants

If you've ever tried to get an AI assistant to help you actually *do* something on your Windows computer — not just tell you *how* to do it — you've probably hit a wall like this:

> *"I don't have direct access to your Windows system settings, so I can't check or change remote connection settings on your behalf."*

> *"I appreciate you asking, but there are a couple of important limitations here: I can't install software on your Windows computer. I have access to a sandboxed Linux environment for running code, but that's separate from your actual Windows system. I have no way to download or install applications like Cygwin or Python onto your PC directly."*

These are real responses from browser-based AI tools like "Claude Cowork" (Claude.ai in a chat window). They're not wrong in this context, but the limitation is narrower than "can only give advice": Claude Cowork can work with local files you expose to it and automate tasks that live inside the Chrome browser. What it still can't do is directly administer your Windows machine end-to-end the way an SSH-connected agent can.

But what if Claude could actually *do* it?

That's exactly what **Claude Code, Codex, Gemini, or any smart agent** with SSH access enables. Once your Windows machine is reachable over SSH, the agent — running on another machine on your network — can log in, run commands, read files, edit the registry, and manage your system end-to-end. No GUI required. No copy-pasting commands. You just ask.

---

## Part 1: The Hard Part — Making Windows SSH-Accessible

The one-time setup requires physical or RDP access to the Windows machine. After that, you'll never need it again.

### Step 1: Install Cygwin with OpenSSH

Download the Cygwin installer from [cygwin.com](https://www.cygwin.com) and install it. During package selection, make sure to include:

- `openssh` — the SSH server and client
- `cygrunsrv` — used to register Cygwin services as Windows services (will be included in standard installation)
- `bash`, `coreutils`, `grep`, `sed`, `awk`, `findutils` — standard Unix tools (often included in standard installation)
- `git` — useful for cloning repositories and working with source code

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/04/managing-windows-made-easy-with-cygwin-and-claude/2026-04-15-20-08-42.png)

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2026/04/managing-windows-made-easy-with-cygwin-and-claude/2026-04-15-20-14-53.png)

The default install path is `C:\cygwin64`.

### Step 2: Clone the Setup Scripts

The scripts are available on GitHub. Open a Cygwin terminal (not PowerShell yet) and clone the repo:

```bash
git clone https://github.com/e-tang/installcygwinsshd
cd installcygwinsshd
```

The repo contains two scripts:
- **`installsshd.ps1`** — installs and configures the Cygwin SSHD service
- **`verify.ps1`** — verifies the installation is working correctly

Basically, to install / enable the sshd service:
```bash
ssh-host-config --yes --cygwin 'ntsec' --name 'sshd' --port 22 --user 'cyg_server'
```

### Step 3: Run the Install Script

Open PowerShell **as Administrator** and run:

```powershell
cd C:\path\to\installcygwinsshd
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\installsshd.ps1
```

What the script does:
- Runs `ssh-host-config` inside Cygwin to generate host keys and create a `cyg_server` service account
- Sets the `CYGWIN=ntsec` environment variable (required for proper permissions)
- Opens port 22 in Windows Firewall
- Sets the `sshd` service to start automatically and starts it immediately

### Step 4: Verify the Setup

Still in the Administrator PowerShell, run:

```powershell
.\verify.ps1
```

### Step 4: Set Up SSH Key Authentication

From your Linux/Mac machine (or another machine running a smart agent: e.g. Claude Code), copy your SSH public key to the Windows machine so you don't need a password every time:

```bash
ssh-copy-id username@a-win-machine
```

You'll be prompted for the Windows user password once. After that, all SSH connections use your key. If `ssh-copy-id` isn't available, do it manually:

```bash
# On the client machine, copy your public key
cat ~/.ssh/id_ed25519.pub

# Then on the Windows machine (via password SSH), paste it into:
# C:\cygwin64\home\username\.ssh\authorized_keys
```

Also add the host to your known_hosts to avoid interactive prompts:

```bash
ssh-keyscan a-win-machine >> ~/.ssh/known_hosts
```

Once this is done, you can SSH in silently:

```bash
ssh a-win-machine "uname -a"
# CYGWIN_NT-10.0-19045 a-win-machine 3.6.7-1.x86_64 ...
```

That's it. **The hard part is over.** From this point on, you manage the machine through Claude Code — just by asking in plain English.

---

## Part 2: The Easy Part — Let Claude Do the Work

### Real Example: Removing Riot Games Completely

Here's a real session. I simply told Claude Code:

> *"I need you to remove / delete 'Riot Games' for me"*

Claude SSHed in, found the installation, confirmed before deleting, removed the directories, then I asked it to clean the registry too. Here's exactly what it did — autonomously:

**1. Locate the installation:**
```bash
ssh a-win-machine "find /cygdrive/c -maxdepth 2 -iname '*riot*' -type d 2>/dev/null"
# /cygdrive/c/ProgramData/Riot Games
# /cygdrive/c/Riot Games
# /cygdrive/c/Riot Games/Riot Client
```

**2. Check for running processes before deleting:**
```bash
ssh a-win-machine "tasklist.exe | grep -i riot"
# (nothing running — safe to proceed)
```

**3. Delete the directories:**
```bash
ssh a-win-machine "rm -rf '/cygdrive/c/Riot Games' '/cygdrive/c/ProgramData/Riot Games'"
```

**4. Search the registry for leftover keys:**
```bash
ssh a-win-machine "reg.exe query 'HKLM\\SOFTWARE' /f 'Riot' /k"
ssh a-win-machine "reg.exe query 'HKCU\\SOFTWARE' /f 'Riot' /k"
```

**5. When I mentioned "but it started when the computer starts"**, Claude found it immediately:
```bash
ssh a-win-machine "reg.exe query 'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run'"
# RiotClient  REG_SZ  C:\Riot Games\Riot Client\RiotClientServices.exe --launch-background-mode
```

**6. Deleted the startup entry:**
```bash
ssh a-win-machine "reg.exe delete 'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run' /v RiotClient /f"
```

Total time: a few minutes of conversation. No GUI. No digging through Add/Remove Programs. No regedit hunting. Just asking.

---

## Part 3: What Else Can You Do?

Once Claude Code has SSH access to your Windows machine, the possibilities are broad. Here are examples of tasks you can just *ask* for:

### Software Management

```
"Install Python 3.12 silently"
"Check what version of Node.js is installed"
"Uninstall all Adobe products"
"List all installed programs and their versions"
```

Claude can use `winget`, `choco`, or direct installers:
```bash
ssh a-win-machine "winget.exe install Python.Python.3.12 --silent"
ssh a-win-machine "winget.exe list | grep -i node"
```

### Windows Services

```
"Stop and disable the Windows Search indexing service — it's slowing down the disk"
"Restart the print spooler"
"Show me all services that are set to auto-start but are currently stopped"
```

```bash
ssh a-win-machine "sc.exe stop WSearch && sc.exe config WSearch start= disabled"
ssh a-win-machine "sc.exe query type= all state= all | grep -B1 'STOPPED' | grep 'SERVICE_NAME'"
```

### Startup and Scheduled Tasks

```
"Show me everything that runs at startup"
"Remove that suspicious MLWapp startup entry"
"Create a scheduled task to run a backup every night at 2am"
```

```bash
ssh a-win-machine "reg.exe query 'HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run'"
ssh a-win-machine "schtasks.exe /create /tn 'NightlyBackup' /tr 'C:\\backup.bat' /sc daily /st 02:00"
```

### Disk and File Management

```
"Find the 20 largest files on C: drive"
"Delete all .tmp files in AppData"
"How much space is left on each drive?"
```

```bash
ssh a-win-machine "df -h /cygdrive/c /cygdrive/d"
ssh a-win-machine "find /cygdrive/c/Users/dev/AppData -name '*.tmp' -delete"
ssh a-win-machine "du -sh /cygdrive/c/* 2>/dev/null | sort -rh | head -20"
```

### Registry Management

```
"Disable Cortana telemetry in the registry"
"Find all registry keys pointing to a deleted program path"
"Back up the HKCU Software hive before I make changes"
```

```bash
ssh a-win-machine "reg.exe export HKCU\\SOFTWARE C:\\backup\\hkcu_software.reg"
ssh a-win-machine "reg.exe add 'HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\Windows Search' /v AllowCortana /t REG_DWORD /d 0 /f"
```

### Network and Firewall

```
"Show me all open ports and what's listening on them"
"Block port 8080 in the firewall"
"What's my current IP address and DNS servers?"
```

```bash
ssh a-win-machine "netstat.exe -ano | grep LISTENING"
ssh a-win-machine "New-NetFirewallRule -DisplayName 'Block 8080' -Direction Inbound -Protocol TCP -LocalPort 8080 -Action Block" 
ssh a-win-machine "ipconfig.exe /all"
```

### System Health and Monitoring

```
"What processes are using the most CPU right now?"
"How long has this machine been running?"
"Show me the last 20 error events from the System event log"
```

```bash
ssh a-win-machine "tasklist.exe /fo csv | sort -t',' -k5 -rn | head -10"
ssh a-win-machine "wmic.exe os get LastBootUpTime"
ssh a-win-machine "powershell.exe -Command \"Get-EventLog -LogName System -EntryType Error -Newest 20 | Format-List TimeGenerated,Message\""
```

### Windows Updates

```
"Check if there are pending Windows updates"
"Install all available updates and tell me when it's done"
```

```bash
ssh a-win-machine "powershell.exe -Command \"Get-WindowsUpdate\"" 
ssh a-win-machine "powershell.exe -Command \"Install-WindowsUpdate -AcceptAll -AutoReboot\""
```

---

## Why This Beats Browser-Based AI

<Table data={{
    headers: ["Capability", "Browser AI (Claude Cowork)", "Claude Code + Cygwin SSH"],
    rows: [
        ["Read files on your PC", "Yes", "Yes"],
        ["Delete files or programs", "Yes", "Yes"],
        ["Edit the registry", "No", "Yes"],
        ["Manage Windows services", "No", "Yes"],
        ["Run PowerShell commands", "No", "Yes"],
        ["Set up scheduled tasks", "No", "Yes"],
        ["Monitor processes", "No", "Yes"],
        ["Install software", "No", "Yes (via winget/choco)"],
        ["Fix startup items", "No", "Yes"],
        ["Works without GUI", "No", "Yes"],
    ],
}}
/>

The browser-based assistant can mostly *advise*. Claude Code with SSH access can *act*. The gap is enormous.

---

## Tips for Day-to-Day Use

**Give your Windows machine a stable local hostname.** Whether via your router's DHCP reservation or `C:\Windows\System32\drivers\etc\hosts` on the client, `ssh a-win-machine` is much nicer than an IP address `ssh 192.168.X.X`.

**Keep SSH keys, not passwords.** Run `ssh-copy-id` once. After that, Claude Code can SSH in without any credential prompts — fully automated.

**Cygwin gives you Unix tools on Windows.** `grep`, `find`, `awk`, `sed`, `curl` all work inside your SSH session. You're not limited to `cmd.exe` syntax. Mix PowerShell (`powershell.exe -Command "..."`) with Unix tools freely.

**Combine with Claude Code's file editing.** Claude Code can read and edit config files directly over SSH, not just run commands. Got a broken `sshd_config`? Claude can fix it in place.

**It's auditable.** Every command Claude runs goes through the SSH session you can see. Unlike opaque agent frameworks, you can watch exactly what's happening.

---

## Conclusion

The one-time setup — installing Cygwin, running two PowerShell scripts, copying your SSH key — unlocks something genuinely powerful: a Windows machine you can manage entirely through conversation.

No more digging through nested menus. No more manually hunting for registry keys. No more wondering which startup entry belongs to which program. You describe what you want, Claude figures out how to do it, and it's done.

Browser-based AI tools will tell you to "open regedit and navigate to...". Claude Code with SSH will just do it.


2b98dc65befd9b586cd6103472ab7a81c42cf32a8530ee698f7048c5066dd26a

A practical guide to setting up Cygwin SSHD on Windows and using Claude Code to manage it remotely — far beyond what browser-based AI assistants can do.

Stop fighting with Windows GUIs. With Cygwin, an SSH daemon, and Claude Code, you can manage any Windows machine from the command line — uninstalling software, cleaning the registry, killing startup entries — just by asking.

Managing Windows Made Easy with Cygwin and Claude

{/* banner prompt: Excellent! This is a great blog post that tells a clear story of a problem, a solution, and the resulting empowerment. Here are a few creative and engaging prompts for the banner image, ranging from conceptual to more literal, all designed to capture the essence of the post.

### Prompt Option 1 (Conceptual & Dynamic)

This prompt focuses on the partnership between the human and the AI, showing the AI as a powerful tool that untangles complexity.

**Prompt:**
> A dynamic digital art scene of a developer collaborating with a luminous AI entity. On a holographic interface floating between them, tangled, broken lines of red code representing bugs are being methodically repaired and woven into clean, flowing green code by the AI's energy. In the background, abstract cloud and DNS icons glow softly, symbolizing the Cloudflare API being fixed. The overall mood is one of breakthrough and efficiency, with a sleek, futuristic aesthetic. --ar 16:9

### Prompt Option 2 (Metaphorical & Powerful)

This prompt uses the metaphor of a bridge being repaired, which directly reflects the story of fixing a broken tool to connect the developer's intent to the API's function.

**Prompt:**
> Cinematic digital illustration of a broken bridge made of glowing code connecting a developer's command-line terminal to a massive, stable cloud structure representing the Cloudflare network. A sleek, intelligent AI, depicted as a focused beam of light or a robotic entity, is rapidly reconstructing the broken sections of the bridge, transforming chaotic red error symbols into solid, green success pathways. The scene is set in a dark, high-tech environment, emphasizing the AI as a beacon of solutions. --ar 16:9

### Prompt Option 3 (Direct & Action-Oriented)

This prompt is more direct, showing the "before and after" of the debugging process within a single, compelling image.

**Prompt:**
> A split-view digital artwork in a modern, tech-themed style. On the left, a frustrated developer is looking at a terminal screen filled with red error messages like "Invalid request headers" and "ENOENT". On the right, the same developer now looks confident as a helpful, transparent AI avatar hovers beside the screen, which now displays a stream of green "✓ Success!" messages and successfully executing CLI commands. The AI is pointing to the fixed code, bridging the gap between error and success. --ar 16:9

---

**Recommendation:**

**Prompt 1** is the most balanced and creative. It captures the core themes of AI collaboration, bug fixing, and open-source empowerment in a visually stunning and modern way without being overly literal. It provides the image generator with rich concepts like "luminous entity," "tangled red code," and "flowing green code" to create a unique and engaging banner. */}

## Introduction

In today's fast-paced development world, managing DNS records manually through web interfaces is time-consuming and error-prone. As someone who frequently needs to update DNS configurations across multiple domains, I wanted a better solution—a command-line tool that AI could use to automatically construct and execute commands based on the information I provide.

When I tried to set up domain for my a Google Cloud project, the below are the DNS records I needed to add:

{/* | Type  | Data                      | Alias |
|-------|---------------------------|-------|
| A     | 216.239.32.21             |       |
| A     | 216.239.34.21             |       |
| A     | 216.239.36.21             |       |
| A     | 216.239.38.21             |       |
| AAAA  | 2001:4860:4802:32::15     |       |
| AAAA  | 2001:4860:4802:34::15     |       |
| AAAA  | 2001:4860:4802:36::15     |       |
| AAAA  | 2001:4860:4802:38::15     |       |
| CNAME | ghs.googlehosted.com      | www   | */}

<Table data={
  {
    headers: ['Type', 'Data', 'Alias'],
    rows: [
      ['A', '216.239.32.21', ''],
      ['A', '216.239.34.21', ''],
      ['A', '216.239.36.21', ''],
      ['A', '216.239.38.21', ''],
      ['AAAA', '2001:4860:4802:32::15', ''],
      ['AAAA', '2001:4860:4802:34::15', ''],
      ['AAAA', '2001:4860:4802:36::15', ''],
      ['AAAA', '2001:4860:4802:38::15', ''],
      ['CNAME', 'ghs.googlehosted.com', 'www'],
    ],
  }
} />

And I am too lazy to click through the Cloudflare web dashboard to add them one by one. That's when I discovered [cloudflare-cli](https://github.com/danielpigott/cloudflare-cli) (cfcli), a promising Node.js tool for managing Cloudflare DNS records from the terminal. The vision was simple: I could tell an AI assistant "update these DNS records for my domain," and it would construct the proper cfcli commands and execute them automatically.

But there was a problem — cfcli was broken.

## The Problem: A Broken Tool

### The Configuration File

Cfcli requires a configuration file (`~/.cfcli.yaml`) containing your Cloudflare API credentials. I created mine with the following content:

```yaml
defaults:
   account: work
accounts:
   work:
      token: "p9XvQ2s7LwT8zR4bJ6yNf0c3KjHqWmVtSdFgLbXy"
       email: "eric@tyo.com.au"
       domain: example.com

```

When I first tried to use cfcli, I immediately ran into two critical bugs:

### Bug #1: Missing help.txt File

```bash
$ cd /tmp
$ cfcli help
Error: ENOENT: no such file or directory, open '/tmp/doc/help.txt'
```

Running cfcli from any directory outside its installation folder caused it to crash when trying to display help documentation.


### Bug #2: Invalid Request Headers

```bash
$ node ./bin/cfcli zones
Error response received: Invalid request headers
```

Every API request to Cloudflare was failing with cryptic "Invalid request headers" errors. The tool was completely unusable.

Initially, I used Google Gemini to run cfcli commands and update DNS records for me, but it kept failing due to these bugs. And Gemini simply gave up and asked me to update those records manually.

![](https://storage.googleapis.com/www-tyolab-com-blog-assets/images/blog/2025/10/empowering-open-source-development-with-ai-my-experience-fixing-cfcli/Screenshot_2025-10-04_17-01-24.jpg)

## Why This Mattered

These bugs weren't just inconvenient—they completely blocked my automation workflow. I needed cfcli to work reliably so that AI tools like Google Gemini, Claude Code, OpenAI Codex or others could:

1. **Automatically construct commands** based on natural language requests
2. **Execute DNS updates** without manual intervention
3. **Work from any directory** in my system
4. **Handle bulk operations** like updating multiple A, AAAA, and CNAME records at once

Without a working CLI tool, my entire automation strategy fell apart. I could continue using the Cloudflare web dashboard, but that defeated the purpose of having AI assistance.

## Enter Claude Code: From Broken to Fixed in Minutes

This is where things got interesting. Instead of spending hours debugging Node.js code, diving into axios documentation, and testing different configurations, I simply asked Claude Code to help me fix the bugs.

First, I forked the project to my own GitHub account: [e-tang/cloudflare-cli](https://github.com/e-tang/cloudflare-cli).

Then, I started a new conversation with Claude Code, providing the context about the two bugs I encountered.

Here's what happened:

### Step 1: Reproducing the Bug

Claude Code immediately understood the context and ran the local cfcli to confirm the error:

```bash
$ node ./bin/cfcli zones
Error response received: Invalid request headers
```

### Step 2: Intelligent Debugging

Rather than randomly trying fixes, Claude Code:

1. **Analyzed the codebase** to understand how authentication headers were being set
2. **Checked the axios version** (1.12.0) to identify compatibility issues
3. **Created test scripts** to isolate the problem
4. **Tested different authentication methods** (Bearer token vs. API Key)

Through systematic testing, Claude Code discovered that:

- The newer axios version (1.12.0) sets `Content-Type: undefined` by default
- This undefined header causes Cloudflare's API to reject requests
- The deprecated API Key authentication (X-Auth-Email + X-Auth-Key) doesn't work properly with newer axios versions
- Bearer token authentication works perfectly

### Step 3: The Fix

Claude Code implemented two elegant fixes:

**Fix #1: Remove the undefined Content-Type header**
```javascript
// lib/apiClient.js
const client = axios.create({
  baseURL: 'https://api.cloudflare.com/client/v4',
  timeout: 20000
});

// Remove the Content-Type header set to undefined by axios
// which causes issues with Cloudflare API in newer axios versions
delete client.defaults.headers.common['Content-Type'];
```

**Fix #2: Force Bearer token authentication**
```javascript
// bin/cfcli
let params = { ...config, ...argv };
// Remove email from params to force Bearer token authentication
// The old API Key authentication (email + key) is deprecated and causes issues with newer axios
if (params.token && params.email) {
  delete params.email;
}
```

### Step 4: Fixing the Path Resolution Bug

For the second bug, Claude Code identified that `path.resolve()` returns the current working directory, not the module's directory. The fix was straightforward:

```javascript
// index.js
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

showHelp() {
  return Promise.resolve(new Result([
    fs.readFileSync(path.join(__dirname, 'doc', 'help.txt'), 'utf8')
  ]));
}
```

### Step 5: Testing and Validation

Claude Code didn't just fix the bugs—it verified them:

```bash
# Test from the project directory
$ node ./bin/cfcli zones
✓ Success! Listed 4 zones

# Test from a different directory
$ cd /tmp && node /data/tyolab/node/cloudflare-cli/bin/cfcli help
✓ Success! Help text displayed correctly

# Test actual DNS operations
$ node ./bin/cfcli add --domain example.com --type A @ 216.239.32.21
✓ Added A record example.com -> 216.239.32.21
```

### Step 6: Proper Git Commits

Claude Code even created well-documented git commits following best practices:

```
commit e9ff7a6
Fix "Invalid request headers" error with axios 1.12.0

This fixes compatibility issues with the newer axios version (1.12.0)...

commit feef4f7
Fix help command path resolution when run from different directory

Changed from using path.resolve() (which returns current working
directory) to using import.meta.url with __dirname...
```

## The Real Magic: AI-Powered Automation in Action

With cfcli fixed, I could finally achieve my original goal. Here's what happened next:

**Me:** "For my domain example.com, please update them with: A 216.239.32.21, A 216.239.34.21, A 216.239.36.21, A 216.239.38.21, AAAA 2001:4860:4802:32::15, AAAA 2001:4860:4802:34::15, AAAA 2001:4860:4802:36::15, AAAA 2001:4860:4802:38::15, CNAME ghs.googlehosted.com www"

Claude Code immediately:
1. Parsed my natural language request
2. Constructed the proper cfcli commands
3. Executed them in sequence
4. Verified the results

```bash
# Added 4 A records
Added A record example.com -> 216.239.32.21
Added A record example.com -> 216.239.34.21
Added A record example.com -> 216.239.36.21
Added A record example.com -> 216.239.38.21

# Added 4 AAAA records
Added AAAA record example.com -> 2001:4860:4802:32::15
Added AAAA record example.com -> 2001:4860:4802:34::15
Added AAAA record example.com -> 2001:4860:4802:36::15
Added AAAA record example.com -> 2001:4860:4802:38::15

# Updated CNAME record
Added CNAME record www.example.com -> ghs.googlehosted.com
```

What would have taken me 15-20 minutes of clicking through the Cloudflare dashboard took **less than 10 seconds** with AI assistance.

## Lessons Learned

This experience taught me several valuable lessons about AI-assisted development:

### 1. AI Excels at Systematic Debugging

Rather than guessing, Claude Code used a methodical approach:
- Reproduce the error
- Analyze the codebase
- Identify the root cause
- Test potential solutions
- Implement the fix
- Verify it works

### 2. AI Understands Context

Claude Code didn't just fix the immediate bug. It understood:
- The purpose of the tool
- The compatibility issues with newer dependencies
- Best practices for path resolution in ES modules
- Proper git commit message formatting

### 3. AI Accelerates Learning

Throughout the debugging process, I learned about:
- How axios handles headers in different versions
- The difference between API Keys and API Tokens in Cloudflare
- ES module path resolution with `import.meta.url`
- Better patterns for CLI tool development

### 4. The Compound Effect of Automation

By fixing cfcli, I unlocked a new level of productivity:
- **Before:** Manual DNS updates through web UI (15+ minutes per domain)
- **After:** Natural language commands to AI → Automatic execution (seconds)

## The Bigger Picture: AI as a Development Multiplier

This story isn't just about fixing two bugs in a CLI tool. It's about how AI tools like Claude Code are fundamentally changing software development:

### From Bug Fixing to Feature Building

Instead of spending hours debugging, I spent minutes. That freed me to:
- Update DNS records for all my domains
- Write this blog post
- Think about other automation opportunities

### From Manual Work to Intelligent Automation

The combination of AI and CLI tools creates powerful workflows:
1. I describe what I want in natural language
2. AI translates it into technical commands
3. AI executes and verifies the results
4. I review and confirm

### From Isolated Tools to Connected Systems

By fixing cfcli, I created a reliable bridge between:
- Natural language (what I want)
- Technical commands (how to do it)
- Cloud APIs (where it happens)

## Conclusion: Life Becomes Easier with AI

The title says it all—life really does become much easier with AI assistance. But not in the way you might expect.

AI didn't replace my understanding or judgment. Instead, it:
- **Amplified my productivity** by handling repetitive debugging tasks
- **Accelerated my learning** by showing me best practices
- **Enabled new workflows** that weren't practical before

The open source community benefits too. Those two bug fixes are now committed to my local fork, ready to be shared back with the project maintainers. You can find the pull request here: [Fix axios compatibility and path resolution bugs in cfcli](https://github.com/danielpigott/cloudflare-cli/pull/95)

This is the promise of AI-assisted development: not replacing developers, but empowering them to focus on what matters—solving real problems and building valuable tools—while AI handles the tedious details.

## What's Next?

With cfcli working perfectly, I'm exploring more automation opportunities:
- Automated DNS configuration for new projects
- Bulk DNS record management across multiple domains
- Integration with infrastructure-as-code tools
- Automated SSL certificate management

The possibilities are endless when you combine AI intelligence with reliable CLI tools.

---

**Have you used AI to debug open source software?** I'd love to hear your stories. Share them in the comments or reach out on Twitter [@_e_tang](https://twitter.com/_e_tang).

**Want to try Claude Code?** Visit [claude.com/claude-code](https://claude.com/claude-code) to get started with AI-assisted development.

---

*This post was written with assistance from Claude Code—the same AI that helped fix the bugs described in this story. Meta, right?*


<ContactFooter />

cc5986a45e8f91e6feac595ddd12932f209416b208058d8075b09906fb373b46

A practical story of using AI-assisted development to fix open source software bugs, featuring axios compatibility issues and path resolution problems in the Cloudflare CLI tool.

How Claude Code helped me debug and fix critical bugs in cloudflare-cli, transforming a broken tool into a reliable DNS management solution in minutes.

Tag: Automation

Tag: Automation

After Programmers, AI Is Coming for Accountants

Managing Windows Made Easy with Cygwin and Claude

Empowering Open Source Development with AI: My Experience Fixing cloudflare-cli