Let Me Be Upfront
Before I started building Pulsefield I had opened Xcode once. Used the simulator for maybe an hour. That was the full extent of my iOS experience. A couple of years of professional software development behind me, zero of it on Apple's platform.
The backstory is in the previous post. This one is about what building it actually looked like.
Starting with the Wrong Tool
The obvious first move was ChatGPT. I'd been using it since late 2022 and it was what I knew. The workflow was predictable: describe what I want, copy the output, paste it into Xcode, see what breaks, paste the error back, repeat.
It worked, technically. But it was slow. Context evaporated between turns. Code quality was inconsistent, especially as the project got more complex. I kept hitting ceilings — not because the ideas were wrong, but because the tool couldn't hold enough of the problem at once to help me push through them.
Around the same time, the company I work for had started leaning into Claude for day-to-day development. I tried it on a few Pulsefield problems I'd been stuck on. The difference was immediately obvious — not marginal, not subtle, genuinely obvious. I bought a private Claude Pro subscription without much deliberation.
Twenty dollars. It turned out to be the cheapest useful expense in the entire project.
Plugging It Into Xcode
I integrated Claude directly into Xcode — not as a chat window I was copying from, but as an agent with full access to the codebase. It could read files, write files, trigger builds, read compiler output, and iterate based on what it found.
At its best this was something else entirely. The agent held context across multiple files simultaneously. When a data model changed, it traced the ripple effects. It wrote tests alongside implementations. It caught issues I wouldn't have found for hours. The Core Haptics engine, the Game Center leaderboard, the StoreKit 2 purchase flow, full VoiceOver accessibility support — all of it came together faster than it would have working solo.
There's a specific kind of momentum that builds when you're spending your time reviewing and deciding rather than looking up documentation for an API you've never touched before. The agent handles the unfamiliar surface area. You handle the judgment calls. It's a genuinely good split.
Part of what makes it work is what Anthropic have built around the whole experience. The model, the interface, the quality of output — it has a polish to it that makes you trust it. And trust makes you lean in. I found myself working deep into the night more than once, not out of obligation but because the next thing felt close. There was always a next thing.
The usage bill tells the story honestly. $5 down when a session was running long. Another $5 an hour later. $10 on a particularly ambitious refactor. Fifty dollars in a week before I'd properly accounted for it. At one point Anthropic added a $20 credit to my account — a gift, and one that landed at exactly the moment I'd burned through more than I'd planned to spend. I thought about what it means that a company is that confident in their product. You try it. You keep going.
The Three Simulator Incident
There's a ritual that develops. You write a prompt you know will run long — a complex refactor, a multi-file integration, something the agent will genuinely need time to work through. You hit enter. And then, almost immediately, you flip to claude.ai in the browser.
From there you can watch the usage percentage update in close to real time. I'd hit refresh every few seconds. The number climbs slowly at first. 35%. Then faster. 60%. The MacBook fans start somewhere around here.
87%. 92%.
I grabbed my credit card. Added $10. Refreshed. Still climbing. 95%. The machine was getting properly hot, the fan noise had become a real roar, and I was sitting there genuinely uncertain whether the context window would cut off at 99% and leave the task half-finished — or whether the laptop would thermal-throttle into uselessness first.
Neither happened. I let it finish.
Then I looked at what had actually been happening.
I'd set my build destination to my iPhone. My iPhone wasn't plugged in. So the agent had fallen back to the simulator. It ran the build, found issues, fixed the code, and opened the simulator again to verify. Found more issues. Fixed them. Opened the simulator again. Three times.
I had three full iOS operating systems running simultaneously on my laptop. That's why it was so hot. That's why the usage spiked so hard.
The feature worked, for what it's worth.
Where the Limits Show Up
As the codebase grew, the shape of the limitations became clearer.
Task scope matters a lot. A vague "make this better" prompt on a large, interconnected codebase burns through context fast. The agent is reading files, running builds, interpreting output — it adds up. I learned to scope tasks deliberately: one clear goal per session, explicit boundaries.
It doesn't flag what it doesn't know it doesn't know. A few times the agent implemented something using an API in a way that compiled, ran, and looked fine — but wasn't quite right for the use case. I caught these because I could read the code critically. Someone without a software development background might not have. The agent is a multiplier on existing skills, not a substitute for them.
You still own the codebase. When something broke in a way the agent couldn't diagnose, I had to be able to debug it myself. There were a few of those moments. The agent got me there faster, but "there" still required me to understand what was happening.
My Honest Take
Claude as a coding agent is not a magic shortcut. It doesn't make you a developer if you aren't one. What it does is dramatically compress the learning curve for unfamiliar territory — in my case, an entire platform and ecosystem I'd never worked in before.
The combination of genuine programming fundamentals and a capable agentic tool is meaningfully powerful. Neither works as well without the other.
Pulsefield is my app. I made the decisions, I understood the code, I debugged the failures. But I didn't build it alone, and I'm not going to pretend otherwise. The $20 Pro subscription was the best value purchase in the whole project — by a significant margin.