# I tried using an AI agent to set up a fresh Windows PC and Reddit was right about Ninite

> Source: <https://dev.to/lars_winstand/i-tried-using-an-ai-agent-to-set-up-a-fresh-windows-pc-and-reddit-was-right-about-ninite-37da>
> Published: 2026-08-05 18:34:15+00:00

I tried the obvious nerd experiment on a fresh Windows machine: let an AI agent handle setup.

It looked clever for about two minutes.

Then I watched OpenClaw get stuck on installer checkboxes, pause on modal windows, and generally do the digital equivalent of forgetting why it walked into the room.

While it was still fighting one installer, I switched tactics:

That combo finished 18 app installs before the agent recovered.

And after reading through [this r/openclaw thread](https://reddit.com/r/openclaw/comments/1vg56gy/can_i_use_openclaw_to_setup_my_pc/), I think the real lesson is bigger than Windows setup:

**GUI-driving agents are the wrong abstraction for deterministic work.**

If the task is "figure out what this machine needs," use a model.

If the task is "install these 18 things and stop being interesting," use scripts.

I’m not anti-agent.

I’m anti-fragile-automation.

OpenClaw, GPT-5, and Claude are useful when the problem is ambiguous:

They are much less useful when the problem is fully deterministic:

`Next`

That second category is where WinGet, Ninite, and PowerShell win by being boring.

Boring is good.

This is the same pattern you see in real automations in n8n, Make, Zapier, or custom agent workflows:

That architecture is faster, easier to debug, and usually cheaper.

Here’s the split I’d use again.

| Job | Best tool |
|---|---|
| Install common desktop apps fast | Ninite |
| Create a repeatable developer setup | WinGet |
| Apply system config and automation | PowerShell |
| Turn vague requirements into a plan | GPT-5 or Claude |
| Drive random installer UIs | Only if you have no better option |

Because for the first hour of a clean Windows install, Ninite is still ridiculously efficient.

If you want a bundle like:

Ninite is hard to beat.

You pick the apps, download one installer, run it once, and move on.

No vendor site scavenger hunt.

No adware checkbox archaeology.

No ten-tab install ritual.

That’s why Reddit keeps bringing it up. It solves the obvious problem with very little ceremony.

WinGet wins the moment you care about repeatability.

That means:

A few useful commands:

```
winget search vscode
winget install --id Microsoft.VisualStudioCode -e
winget install --id Docker.DockerDesktop -e
winget install --id Git.Git -e
winget install --id Python.Python.3.12 -e
```

Export what’s installed:

```
winget export -o apps.json
```

Import later on a new machine:

```
winget import -i apps.json
```

That is a much better foundation than hoping an agent can survive every installer UI variation.

This is the workflow I’d recommend to most developers.

Prompt example:

```
I’m setting up a fresh Windows 11 machine for backend development.
I need Python, Node.js, Docker Desktop, VS Code, Git, Postman, WSL, and Ollama.
Give me:
1. A recommended install order
2. WinGet package IDs where possible
3. PowerShell commands for setup
4. Any dependencies or gotchas
```

This is where models shine. They can:

Grab the common apps fast.

Use it for the stuff that doesn’t need debate.

Example:

``` php
$packages = @(
  "Microsoft.VisualStudioCode",
  "Git.Git",
  "Python.Python.3.12",
  "OpenJS.NodeJS.LTS",
  "Docker.DockerDesktop",
  "Postman.Postman"
)

foreach ($pkg in $packages) {
  winget install --id $pkg -e --accept-package-agreements --accept-source-agreements
}
```

Example:

```
wsl --install
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
mkdir $HOME\dev -ErrorAction SilentlyContinue
git config --global init.defaultBranch main
git config --global pull.rebase false
```

If some weird installer has no package and no silent install option, fine.

That’s where OpenClaw-style control can help.

But that should be the exception, not the architecture.

This is the pattern that scales beyond PC setup.

You can ask GPT-5 or Claude to draft a script like this:

``` php
$apps = @(
  "Microsoft.VisualStudioCode",
  "Git.Git",
  "Python.Python.3.12",
  "OpenJS.NodeJS.LTS",
  "Docker.DockerDesktop"
)

foreach ($app in $apps) {
  Write-Host "Installing $app"
  winget install --id $app -e --silent --accept-package-agreements --accept-source-agreements
}

Write-Host "Done"
```

That’s a much better use of AI than asking it to literally watch the screen and guess where the `Next`

button moved.

This is not just a Windows post.

It’s the same design decision you make in any serious automation:

Use the model for:

Use deterministic tools for:

That split is what makes agents useful instead of expensive theater.

This is where the PC setup experiment connects directly to production automation.

Once you start using GPT-5 or Claude in loops for:

per-token pricing gets annoying fast.

Not because the models are bad.

Because repetitive operations multiply cost in ways that are hard to predict.

That’s exactly why flat-rate compute is interesting for developers building agents and automations.

If your workflow architecture is "model thinks, script executes," you still want the model available constantly for the parts that need judgment. You just don’t want every retry and planning pass to feel like a billing event.

That’s the appeal of [Standard Compute](https://standardcompute.com):

That pricing model makes a lot more sense for agent-heavy systems than pretending every workflow can be reduced to a single cheap completion.

Reddit was right about Ninite.

But only for the first layer of the problem.

My take after doing this the dumb way first:

The winning pattern is not "let the agent do everything."

It’s:

That turned out to be the useful lesson from a silly fresh-PC experiment.

The agent only became helpful once I stopped asking it to pretend to be a mouse.

If you’re building setup flows, onboarding scripts, or agent automations, that distinction matters a lot more than the demo does.