AI-Driven Development: Insights from Day One

Hello from February 2026, where the way we as software developers get our jobs done on a daily basis is in the process of changing rapidly, with the advent of AI code-writing tools! 

Today being a company holiday (Presidents' Day here in the U.S.), I decided to spend the day getting in some self-guided hands-on practice with using some of this new AI tooling. Specifically, I decided to implement a user-requested feature for TimeSnapper for MacOS: Zoom-in / zoom-out functionality on images displayed in the playback view. I'd do this not by coding the feature myself -- as I'd always have needed to do in the past -- but by having AI write the code for me. 

For context: TimeSnapper is a utility app that runs in the background on your Mac or Windows computer, and captures screenshots every few seconds, making it possible for you to go back and look at what you were seeing earlier in the day (or even on previous days). Here's what the playback window looks like in the Mac version:

I didn't spec out a whole lot of requirements up front. I generally just wanted the zoom functionality to work "as a user would expect" -- i.e., having more or less the same familiar user experience as when using the Preview (image viewing) or Apple Maps apps on a Mac.

For the AI tooling, I used Claude Code v2.1.42 with the Claude Sonnet 4.5 model, running in a terminal window in my repository's directory. For the IDE, I used the standard XCode 16.4 atop my MacOS Sequoia.

Hey little sister, what have you done? 

Here's what I went with for my initial Claude prompt:

TimeSnapper (this repository) is an application that runs in the background and periodically takes screenshots of what the user is working on, for the user to review later. The PlayYourDay* project files implement a window where the user can review screenshots. The PlayYourDayImageView is where the screenshots are actually displayed to the user. Change or replace that view to allow the user to pan and zoom the image being displayed. Some specific requirements:

• The user should be able to zoom in with the keyboard shortcut cmd+=, zoom out with cmd+-, and restore the zoom to the default level with cmd+0
• The user should be able to zoom in and out by holding the cmd key and scrolling the mouse wheel up and down.
• When the image is larger than the window, the window should render scroll bars to allow the user to pan the visible portion of the image.
• When the image is larger than the window, the user should be able to pan the image by holding down the left mouse button and moving the mouse. 

The model "thought" for several minutes, and then made some changes to my project's files.  

So, I went ahead and shipped the changes to the App Store!

...In actually, no. I did not do that. (Although I imagine that there now are folks out there shipping apps this way: What's stopping them? Read on for why it's probably a good thing that I didn't just vibe-and-ship!)

Instead, I took at pass at reviewing what the AI had done, by:

1. Reading through the output in the Claude window;
2. Reading through the changes to the source files (using GitHub desktop);
3. Testing out the changes in my local running TimeSnapper app. 

It turns out that, for me, today, only that 3rd item had much value. Claude's explanation of what it was doing showed that it seemed to be on the right track, and didn't include anything that looked "off." Likewise, the code changes all seemed plausible; I didn't spot anything egregious. 

So, I proceeded with testing the changes. In retrospect, I basically acted as a QA engineer counterpart to Claude as the software developer. (On top of the "product manager" and "UX designer" hats I was already wearing to tell Claude what to build in the first place.)

Initially, I was impressed by the changes! I could indeed zoom the image in and out by pressing cmd+-  / cmd+=. I could also zoom the image using cmd+mousewheel. I could pan the image with a left-click drag. This was a pretty striking improvement over "no zoom or pan functionality at all", as was previously the case!

Once I got past the surface level of the new functionality, however, I pretty quickly noticed some issues with the behavior. I decided to go ahead and have Claude iterate on what it had built. So, without clearing Claude's context, I told it:

It works pretty well, but there are some bugs:

1. When panning the image by holding down the left mouse button and moving the mouse, moving the image left/right works correctly, but moving the mouse up/down moves the image in the OPPOSITE direction that the mouse is moving. The image should move in the same direction.
2. When the image is zoomed in, after pressing Cmd+0 to restore the default zoom level, the image is still partially vertically panned out of the viewable area of the window. The image should automatically be moved to be within the viewable area of the window, if possible.
3. Trying to zoom in the image past 100% doesn't work. Upon a Cmd+= key press, the image moves up and to the right, but it doesn't "zoom in" (visibly become any larger). The "canvas" (the scrollable area of the window) _does_ become larger, but the image itself doesn't correspondingly change size to fit.

Claude again "thought" for a couple of minutes, then made another round of code changes. Ok! I jumped in to QA the changes again -- and found that the drag-to-pan functionality was no longer working. I also noticed an additional bug: The right-click context menu for the displayed image no longer appeared adjacent to the mouse cursor, but (for some reason) below the playback window. 

Once again, I told Claude the problems; a couple of minutes elapsed; Claude made some code changes; I QA'ed; and I noticed additional bugs/problems and/or regressions. A sampling of these additional problems, each encountered after a round of having Claude make changes, and me manually testing the results:

• When pressing Cmd+0 to restore the default zoom level, the image is vertically scrolled down past the bottom of the viewable area of the window.
• When beginning to pan the image using left-click-drag, as soon as the mouse is dragged a little bit, the image "snaps down" and partially moves below the bottom of the viewable area of the window.  
• When panning around the image, during the mouse drag, the position of the image "stutters" a bit: It abruptly jumps back and forth by about 20 pixels. 
• When zooming the image using cmd + mouse wheel (in either direction -- either zoom in or zoom out), the vertical position of the image changes, such that there is now empty space between the top edge of the image, and the top edge of the window.
• Regression: The mouse wheel zoom should be "centered" on the mouse cursor position, but it is instead centered on the lower-left corner of the image. 

During this whole process, I was jotting down my observations and insights (during those 2-3 minute periods while Claude was working on each set of changes). A couple of insights I had after the first ~75 minutes or so of this:

• From my notes: "I feel like a QA engineer who is dealing with a kind of careless developer who repeatedly keeps 'throwing changes over the wall to QA' without testing them." 
• As Claude repeatedly struggled to successfully fix a couple of specific bugs: "At this point I'm getting concerned that these rounds of changes could be making the codebase worse instead of better. Should I be setting 'save points,' e.g. via git branches? Or should I be doing a commit after each incremental change, and squashing them all when things look ready to publish?"

As I played with the work-in-progress changes, I also realized that there were a few behaviors that I hadn't specified up front to Claude, but that became apparent through the process of playing with the app. These included both minor nuances of behavior, and more significant features. An example of each:

• The zoom "increment" when using the mouse wheel feels best when it is small. When using the keyboard, it feels better to have a bigger increment. 
• Additional feature: Cmd+9 should perform a "Zoom to fit." That is, to set the zoom level as large as possible, with the constraint that the image still fits within the bounds of the window. (Same functionality and keyboard shortcut as the MacOS Preview app.)  

This aspect of software development is nothing new. AI or not, it has always been that case that certain behaviors and requirements are "discovered" during the process of the software being built, rather than having been specified up front. (Y'all have heard of agile, right?) A takeaway that I have from this:

• Having AI write code doesn't solve the bottleneck that occurs when coordination is needed between roles (technical, UX designer, product) as questions arise. The more that the software developer (or whomever is "piloting" the AI) themselves understands the multiple considerations/aspects of the software being written, the lower the cost will be in time and context switching. 

At about the 3-hour mark, I had reached a point where there were still a couple of non-trivial bugs that Claude was having trouble solving. Despite a few rounds of me describing the problematic behavior, and Claude making a set of changes and cheerfully reporting that the problem should now be solved, the bugs persisted. Insight I had at this point, from my notes:

• "I feel like I'm at a point of diminishing returns of the AI. A skilled developer would have initially built the implementation such that all of these remaining persistent issues would not be happening in the first place." 

In other words, I had seemed to have reached a point where the AI's attempts to fix problems by tweaking its implementation just wasn't working. The underlying structure/framework that the AI had built initially at the beginning of the day atop my human-authored master branch was such that it just didn't seem to be able to fixcertain behaviors -- sort of akin to a house that had been built with a creaky frame. 

It's a nice day to start again 

With this in mind -- and remembering how quickly Claude had built its initial implementation (a few minutes) compared to how long I'd gone back and forth with Claude to get the software to be high enough quality that I wouldn't be embarrassed to ship it (multiple hours at this point), I decided to try "starting fresh": I saved what I had so far to a git branch; I went back to the master branch; I cleared Claude's context; and I gave Claude a fresh set of instructions, with more complete requirements, incorporating what I'd learned over the past few hours:

TimeSnapper (this repository) is an application that runs in the background and periodically takes screenshots of what the user is working on, for the user to review later. The PlayYourDay* project files implement a window where the user can review screenshots. The PlayYourDayImageView is where the screenshots are actually displayed to the user. Change or replace that view to allow the user to pan and zoom the image being displayed. Some specific requirements:

• The user should be able to zoom in with the keyboard shortcut cmd+=, zoom out with cmd+-, and restore the zoom to the default level with cmd+0. 
• Upon a cmd+9 press, a "Zoom to fit" operation should happen, with the zoom level being set to a multiple of 0.1 such that the image fits entirely within the window. 
• The default zoom level when the "Play Your Day" window is opened should be 1.0. 
• The zoom increment when zooming with the keyboard should be 0.1.  
• The minimum zoom level should be 0.1. The maximum zoom level should be 5.0. 
• The user should be able to zoom in and out by holding the cmd key and scrolling the mouse wheel up and down. The zoom increment for mouse wheel zooming should be 0.05. 
• When the image is larger than the window, the window should render scroll bars to allow the user to pan the visible portion of the image.
• When the image is larger than the window, the user should be able to pan the image by holding down the left mouse button and moving the mouse. 
• The "View Image File in Finder" context menu should no longer display on left-click -- it should display only on right-click. (Left-click will now be used for the image panning functionality.) 
• The "View Image File in Finder" context menu should always display adjacent to the mouse cursor position, even when the image zoom level is something other than 1.0.
• Whenever the image fits within the window horizontally, the image should be anchored to the left edge of the window.
• Whenever the image fits within the window vertically, the image should be anchored to the top edge of the window (NOT to the bottom edge).

This approach ended up working well (for me, today, for this particular project!). While the resulting implementation still had some problems, Claude seemed to build a more solid "foundation," given the fresh context, and the more complete set of requirements up front. 

Within about an hour of additional rounds of QA and back-and-forth with Claude, I had the zoom feature working to a point where I was happy enough to be able to ship it to the App Store.

Insights from that last hour of work:

• Human attention to detail still matters. I was having Claude fix such minor/nuanced behaviors that I noticed as: After zooming one (small) increment via the mouse wheel, it was not possible to get back to the "default" (100%) zoom level, or to the minimum or maximum zoom levels, via the keyboard (large increments) -- because Claude had implemented keyboard zoom to just add/subtract 0.1 from the zoom factor, rather than having the zoom factor "snap" to the nearest multiple of 0.1. 
• AI does not produce perfect results. The build I ended up shipping still had a minor bug where sometimes, after zooming in or doing a "restore to 100% zoom", the image would be vertically scrolled down slightly (instead of the image being "anchored" to the top-left corner). Despite a couple of attempted rounds of having Claude try to fix this, Claude was unable to do so. I decided that it wasn't (for now) worth my time to manually track this bug down in the Claude-authored code -- which I don't have a deep understanding of, because I didn't write it! -- and fix it.

Take me back home, yeah 

Ultimately, the day was a success! I was able to ship a new feature for TimeSnapper; and I got in some valuable early reps in using AI tooling to write code. 

Wrapping up: A few big obvious caveats apply to this entire post!

• As stated up front, today was the first day where I was able to devote an entire day to playing with AI-driven development. Ask me again how things are going after I've had more chances to do this in a few weeks; or at this time next year. Not to mention the fact that the available tools themselves are undergoing such rapid changes. 
• This project was building on a standalone Objective-C Mac desktop app, with changes focused around new GUI behaviors. Would things have gone differently (better; worse) in some ways if I were instead working on an app with, say, a Python back-end, a React front-end, B2B API integrations, and changes focused around CRUD forms? I bet they would have!

Finally: For what it's worth, this post (as with all posts on this blog) is 100% human-authored, by me. (Although there's currently little stopping this same claim from being made on prose that is AI-generated! Interesting times!)