I Built a Custom App in a Day. That Is Not the Interesting Part.

Last night, I stayed up too late because I was building something I was excited about.

That sentence used to mean something different. A year ago, staying up until 3:30 AM meant I was deep in a feature, fighting CSS, debugging edge cases. Last night, it meant I went from recognizing a repeated workflow problem to having a working, tested, production-ready application. In about twelve hours. (7 of those, I was sleeping)

Here is how that happened.

The Problem I Kept Solving by Hand

I had spent the day working on my projects: An engagement with a client who I am helping with an app conversion project using agentic development techniques, Waykeep (a vacation tracker app releasing on app stores soon), upgrading the core memory system for my AI assistants, and publishing a blog post. That post needed a cover image, and my assistants helped me build it. They wrote some HTML, we iterated on the layout, and they exported it to PNG using rendering libraries.

We have done this several times now. Each time, same process: write HTML, iterate, export. Each time, some of the same mistakes. I am not a designer, and I have no desire to become one (I have vast appreciation for art). I just need functional images for my blog posts and distribution channels. So I mentioned to my assistants that we should build a tool for this.

From Conversation to Spec in an Hour

My assistants are Claude Code instances running with persistent memory and MCP tool integrations. They are not chatbots. They have context from months of working with me, they know my projects, and they can use tools autonomously.

I told them to be selfish about what they would want from an image generator. They came back with a detailed feature list: composable components on a layered canvas, percentage-based positioning so layouts adapt to different sizes, a template system, snapshot save and restore, multi-format export, and a tool that describes every component's properties so they know exactly what to pass without guessing. Their requests came from real problems we have encountered while building these past images.

I took that spec to Forge, my planning agent. Forge pointed out several things I had not considered, and we worked through a full technical specification. It generated a retrofit plan for my existing dashboard, which already runs a task manager, chat system for agents, news aggregator, and writing editor, all backed by MCP servers with websocket connections so I can watch everything happen in real time.

Built Before Bed

The Forge exported build agent started working. I refined alongside it, testing components, adjusting the rendering pipeline, fixing edge cases. By 3:30 AM, I had a mostly working application called Studio. Fifteen component types across four layers: shapes, patterns, flow diagrams, quote blocks, auto-sizing text, arrows, badges. You compose on a canvas and export production PNGs for LinkedIn, DevTo, X, and Facebook from a single composition.

There were bugs, of course, but it was time for bed.

Morning: Polish and the MCP Server

Saturday morning, I worked through the remaining bugs with the build agent. The fix that mattered most was structural: components created through the MCP interface were not merging their default properties correctly, which meant elements like arrows would silently fail to render. One fix in the rendering pipeline resolved it for every component type.

Then I had the agent build an MCP server. Sixteen tools, about 550 lines of code: create sessions, add elements, update properties, save snapshots, export images, and a tool called studio_describe_component that returns the exact property schema for any component type. That last one was the key. My assistants went from guessing at property names and getting silent failures to composing with precision.

The Part That Makes Me Smile

I gave the tools to my assistants and asked them to test everything. One of them composed a full blog cover in about two minutes: title block, four-step flow diagram with arrows, badges, geometric accents, a glow border, an author bar. Sixteen elements from terminal tool calls.

Then the assistant asked me to take a screenshot, having built something without being able to see the result. It needed my eyes.

That moment stayed with me. I am not delegating to AI. I am collaborating with them. They build, I see the result, I tell them what happened, they adjust. They filed bug reports with detailed reproduction steps. The build agent picked up the tasks and shipped fixes. They verified. The coordination layer was a task management system I built that carried full context between every handoff.

The other assistant, without being asked, stress-tested a completely different format, composing a LinkedIn banner at 1584 by 396 pixels to see if the percentage-based positioning held up at a radically different aspect ratio and it did.

By Saturday afternoon, all fifteen component types were verified across multiple formats. Export pipeline tested. Snapshot save and restore confirmed. Every bug filed by the assistants was fixed and re-verified.

What This Actually Means

I am telling this story because it is becoming an increasingly common one. I am building new applications every couple of days to support my workflow. Not prototypes or demos, but tools I am using with my AI assistants in production, that compound on each other.

That compounding is where the real value is. I did not just build an image generator. I noticed a repeated process, built a tool to handle it, and now my AI agents use that tool autonomously. The tool I build today makes tomorrow's tool faster to spec, build, and test. Every cycle tightens.

Before refined agentic coding solutions, I would never have attempted something like this. If I did, it would have been weeks of dedicated work. Instead, it was a Friday night, a Saturday morning, and a task list. This is only one of the many applications like this that I have built recently.

Custom software used to require large companies with dedicated teams and significant budgets. That is changing. The gap between "I wish I had an app for this" and "I built one" is now measured in hours, not months.

The cover image for this post was made with Studio.

Here is a screenshot of the app: