My first attempt at agentic coding happened before I knew that phrase.
I used Microsoft Copilot in a browser to write PowerShell scripts for fleetwide software deployments at the mid-sized healthcare organization where I work. The routine was always the same: copy a script from Copilot, test it, paste the error back, get a revision, and repeat.
A 200-line script could take 20 revisions.
The frustration built with every error. Around revision 18, I would wonder whether it was ever going to work. Then revision 20, 21, or 22 would finally run cleanly.
What a rush.
That feels like a million years ago in AI time.
When the terminal changed everything
I subscribed to Claude on June 9, 2025, and soon moved from browser chats to command-line tools: Claude Code, OpenAI Codex, and, more recently, Grok Build, Google’s Antigravity CLI, and Kimi Code CLI.
A terminal-based coding agent can edit files, preserve every change in Git, run commands and tests, inspect logs, and recover from a bad turn without reconstructing the last hour from a browser transcript. With the right permissions, it can interrogate a workstation or server and summarize in minutes what might take me hours to gather manually.
It can also deploy.
Projects that once looked like weeks of planning, implementation, and testing can sometimes become one long day with one person and an agent. When that goes well, it is amazing. When it does not, the frustration is remarkably familiar.
Sol takes its time
OpenAI released GPT-5.6 broadly on July 9, 2026. Sol is the flagship member of the family, and OpenAI lists its context window at 1,050,000 tokens. I had used it to summarize meeting notes and write a blog post, but this week was my first technical project with Sol running at max reasoning effort.
I wanted a relatively simple utility. I assumed Claude Code running Opus 4.8 might knock it out in a couple of hours.
Sol had other ideas.
It questioned me for at least two hours before writing meaningful implementation code. When a decision required my judgment, it asked one question at a time. When research or read-only inspection could resolve something, it did that instead. I watched Codex compact the conversation at least twice during the question-and-answer phase.
By the time the first implementation commit appeared, the repository already contained 6,244 lines—roughly 49,000 words—of requirements, research, architecture, security, governance, cost, and delivery documentation. It formalized 27 architecture decisions, 76 functional and security requirements, and 56 acceptance criteria. Tests were defined before the implementation they would judge.
This was not vibe coding. It was closer to hiring a very intense enterprise architect who had no intention of touching the keyboard until every unresolved thought had been turned into a document.
Enterprise by default
I am deliberately not describing what the utility does. The relevant point is how far Sol pushed the architecture around it.
The finished project used 19 AWS services and APIs: Budgets, CloudTrail, CloudWatch, EBS, EC2, EventBridge, IAM, IAM Access Analyzer, IAM Identity Center, Identity Store, KMS, Lambda, Organizations, Price List Query API, S3, SNS, STS, Systems Manager, and VPC.
It strongly recommended multi-factor authentication backed by YubiKeys. That was sensible, so I did it.
Development consumed Saturday. Sol deployed through Terraform and the AWS CLI, ran a large set of automated checks, and used Playwright MCP to drive configuration work in the AWS console. It checked for secrets, unsafe subprocess behavior, formatting problems, type errors, policy violations, and unintended changes.
It also separated read-only investigation from production changes. The former could proceed on its own. The latter stayed behind explicit approval boundaries.
No model I have used has pushed enterprise development norms this aggressively without being asked.
Done was not done
The first time Sol said it was finished, the utility did not work at all.
That exposed a failure mode all the planning and tests had missed. Sophisticated process did not make the model infallible. It gave the model a better structure for recovering when reality overruled the plan.
I called it quits for the day. Sol kept working while I stepped away, until my Linux laptop reached its weekly overnight maintenance window, installed updates, and rebooted.
Sunday morning, the first attempt failed.
There it was again: the feeling from revision 18 of an old Copilot-generated PowerShell script. The growing irritation. The suspicion that I had spent all this time constructing something that might never quite work.
This time, though, the cleanup was fast. Sol found the remaining problem, updated the implementation and tests, and got the project across the line.
The calibration
GPT-5.6 Sol on Max is a highly sophisticated product. It does not optimize for the quick hit of immediate code. It tries to reduce ambiguity, preserve decisions, enforce boundaries, anticipate failure, and prove what it did.
It can still be wrong. It can still say “done” too early. And for a genuinely small project, its instinct to build the enterprise around the utility may be too much.
My adjustment is mostly about expectations. Max reasoning is not the setting to choose when I want instant gratification. It is the setting to choose when I care more about the finished system than the speed of the first draft.
In that sense, it feels strangely like those early days in 2025. I need to tolerate the frustration long enough to get to the rush.