Illuminating Patterns

Discovering a New Flow with Software Agents

I had just wrapped up work for the day. Light was still filtering in through a high, narrow window above my desk. I fidgeted in my seat, knowing I wasn’t done for the day. I had an idea. I downloaded and opened Windsurf. Before this moment, I had bounced off of agents for anything beyond basic programming. Notably, I found one agent particularly good with regex (i.e. my perennial nemesis). Beyond this, however, I found agents more effort than they were worth. I was about to have that view of agents completely upturned.

I wanted to build a web scraper. This has been solved so many times, but I’m the type that enjoys projects and writing code in my spare time. So there I sat: Windsurf open, an empty project directory in front of me, an empty chat. Pure possibility.

Prior to this, I’d have begun in a single script file—the kind of personal project that is the antithesis of best practices. The file would have grown and grown as I tested and tweaked. It wouldn’t have mattered. It would be all mine. It didn’t need to pass CI. It didn’t need to be grokked by anyone else. It could be a glorious, tangled mess.

As I stared at this empty chat box, though, I had one thought:

Whatever is built here, I want full context.

This one thought, context, framed my interactions with Windsurf as I worked on this project. As I began to think about what I wanted, I decided I didn’t want a single script file. I wanted something more mature. And given my experience, I decided to carefully frame what I wanted to Windsurf. That first message was two paragraphs long. I didn’t save it. But it went something like this:

Okay, I want to build a web scraper in python. It’s going to scrape data off of M website. I want the entry point of the script to be app.py. I want that to load all my dependencies. I want a directory structure like: X, Y, and Z. My authentication model will live in X, my specific scrapers in Y, etc. I want to use playwright for browser interactions. For any class files you create, I only want them stubbed out. I do not want any business logic to be included at all.

The result was the first revelatory moment. In minutes I was hours into my journey. More than that, this new project followed more sustainable practices than a single tangled file. I had crossed a threshold that felt like having discovered programming all over again. It was immediately energizing.

But I wasn’t done. I had only a skeleton of an idea. Again, I thought to myself,

As I keep building, I want full context.

My earliest concern was to avoid something I had seen others do: ask an agent to solve a problem and receive hundreds, if not thousands, of new lines of code in return. Programming this way, it seemed to me, was a surefire way to exist in eternal Peer Review mode. Not exciting.

Instead, I gave the agent a simple, tightly bound directive:

Great, we have a project. Now I want to start simple. When the app first boots, lets open M website in the main.py file. That’s all I want you to do.

That’s all I asked. That’s all it did. No bloat. No surprises. No mental overhead. It was exhilarating. By keeping my questions tightly bounded I could swiftly move through the work while maintaining context.

As I sat there, with the light slowly fading through my window, I got it. It clicked. Agents aren’t for blindly writing code and hoping for the best. They’re collaborators. Think of it like onboarding a junior developer. You don’t dump the whole codebase on them and say “go.” You hand them a small, clearly defined task. You explain the context, the purpose, and the constraints. Then you check in and adjust. It’s the same here.

That’s powerful. A few hours of tinkering has convinced me we’re in the middle of a seismic shift in how software gets written. Like the early days of object-oriented programming, we’re starting to see new patterns emerge for working with agents.

I’ve already stumbled onto one: when you’re starting a project, let the agent handle broad, boilerplate setup above and beyond framework features. Once you’re into feature development, tightly bound your requests to heighten your own context. These two principles alone can dramatically improve the way you build alongside an agent.