On the small frustrations we learn to work around, and what happened when I started questioning them.

A few days ago, I was trying to figure out why my computer was consuming so much memory.

It was an ordinary troubleshooting session. I had Revit, Navisworks and Foxit open, and something was using far more memory than I expected. I asked an AI collaborator to investigate. We went through the processes, looked at their memory consumption, and eventually identified Foxit as the culprit.

That wasn’t particularly surprising. Some of the drawing binders I work with contain well over a hundred sheets, and the files themselves can be enormous.

What surprised me was where the conversation went next.

I explained how I use those binders. How I move between drawings, search for room numbers, look for elevations, follow references and return to sheets I’ve already visited. How the information I need is sometimes spread across several PDFs, and finding one detail means navigating through hundreds of pages.

I’d been doing this for months. It was frustrating, but I hadn’t really considered the frustration itself to be a problem worth solving. I needed the information. Finding it was the priority. Whatever stood between me and the answer was simply part of the work.

Then my collaborator and I started talking about building a PDF viewer around that workflow, possibly in Rust.

I hadn’t asked for one. I already had Foxit, and until that moment, building another PDF viewer seemed unnecessary.

But we tried.

The Work Was Getting Done

This is the part I’ve been thinking about since.

In engineering coordination, it’s easy to confuse completing a task with having an efficient process for completing it.

If I need to verify a door opening, I’ll find the door schedule, locate the relevant drawing, check the elevation, compare it against the model, and determine whether there’s a discrepancy. If the information is difficult to find, I’ll keep looking. If the reference on one drawing points to the wrong sheet, I’ll try another route. If I have to reopen the same drawings repeatedly, I do.

Eventually, I usually find what I’m looking for. The coordination issue moves forward, and I turn my attention to the next one.

The task is completed. But the time and attention spent navigating the information rarely become part of my assessment of whether the process itself was reasonable.

I was measuring success by whether I found the answer, not by how much unnecessary effort it took to get there. And because I was succeeding often enough, I had stopped questioning that effort.

The frustration hadn’t disappeared. It had simply become familiar.

A PDF Viewer I Hadn’t Planned to Build

The PDF viewer started as an experiment. We found an existing foundation built in Rust and began adapting it to the large drawing binders I work with.

The first objective was straightforward: open large PDFs quickly, keep memory consumption under control, and move between sheets without unnecessary delays.

The early results were encouraging. A 295 MB binder of 106 sheets opened almost immediately. Thumbnails were generated, sheets stayed sharp when zooming, and search could identify which drawings contained a particular room number or phrase.

That alone addressed the original problem.

Then something interesting happened. I gave my collaborator considerable freedom to improve the application however it thought appropriate, and it began suggesting things I hadn’t requested: a wall of drawing thumbnails, recent sheets, saved views, clickable drawing references, navigation history, and a room register.

The room register particularly caught my attention.

Rather than requiring me to enter rooms manually, the viewer reads the text already present in the PDFs. It identifies patterns resembling room numbers and examines the surrounding words across different sheets. Because a room name tends to appear repeatedly beside the same number, the application can use those repeated associations to suggest a name.

It isn’t infallible. Incorrect references, inconsistent naming and scanned drawings remain limitations. But it gives me a way to move through a collection of drawings without first knowing which sheet holds the information.

Within roughly two weeks, what began as a response to a memory problem had become a tool I was using for actual coordination work. We called it Sheetwall, and it now lives at sheetwall.pro.

I still find the speed of that progression surprising. But I don’t confuse a useful two-week-old application with mature software. Working well on the binders I’ve tested is not the same as being reliable across hundreds of projects and environments.

For now, its value is much simpler. I can find information with less effort than before, and I hadn’t fully appreciated how much that mattered until I felt the difference.

A Different Kind of Interruption

Sheetwall wasn’t the first tool to come out of this kind of frustration.

Tack came from a problem that had less to do with engineering documents and more to do with attention: the small tasks that occur to me while I’m busy with something else. Recording one in a conventional task manager often felt disproportionate to the thought I was trying to preserve, so I kept it in my head instead, where it had a habit of returning while I was trying to concentrate.

I didn’t need a more sophisticated way to organize my life. I needed a less disruptive way to remember what I intended to do.

The Difficulty of Pointing at Something

MarkUpX followed a more deliberate path.

In coordination work, a surprisingly large amount of communication consists of showing someone exactly what you’re talking about. A screenshot with an arrow. A photograph with a cloud around a discrepancy. A drawing with a dimension or a note. Sometimes several images placed together so someone can see the relationship between them.

The underlying task is simple: I need to point at something and explain why it matters. The tools involved don’t always make that simple.

MarkUpX began as an Android application for annotating photographs, screenshots and PDFs. It went through testing, reached production on Google Play, and then spent roughly a month and a half being refined through actual use.

Only afterwards did I seriously explore bringing it to the browser. Could someone paste a screenshot, annotate it and copy the result without installing anything, creating an account or uploading their work to a server?

That became MarkUpX Web, at markupx.app. It now supports placing multiple pictures on a canvas, annotating them, working with PDFs and exporting the result.

What’s been most interesting is what happened once I started using it on my phone.

The features worked. The interface looked good. I could place photographs together, add arrows, labels and dimensions, and produce something useful. Yet I kept creating annotations when I meant to move or deselect an existing one.

I’d tap a text label and reopen its editor. Tap outside to dismiss it, and create another label instead. Try to draw a polyline over an existing rectangle, and select the rectangle rather than place the next point.

None of these problems made the application unusable. They simply made me work harder than necessary, which is rather ironic, considering why I built it.

It reminded me that removing friction isn’t something you accomplish once by creating an application. The application itself can introduce new friction. Sometimes the most valuable improvement isn’t another feature, but making an existing interaction behave the way a person naturally expects.

What Changed Wasn’t Just the Technology

I have worked with AI collaborators extensively throughout these projects, and they have made a considerable difference to what I can attempt.

I am not a professional Rust developer, nor did I set out to become one. I don’t have a software team working on these applications. What I do have is direct experience with the problems I’m trying to solve, enough technical understanding to question the results, and tools that can investigate, implement and test ideas at a speed I wouldn’t have considered practical not long ago.

With MarkUpX, the process was structured: an idea became an Android application, passed through testing, reached production, and gradually expanded. With Sheetwall, it was almost accidental: a performance investigation became a discussion about drawing navigation, then an experiment, then a working application.

In both cases, the important part wasn’t asking a collaborator to write code. It was explaining the working environment well enough that my collaborator could reason about the actual problem.

There were also moments when I deliberately stopped specifying the solution. Some of Sheetwall’s most useful features were proposed without me asking for them individually. That has changed how I think about working with these systems: describe the problem, give the constraints, let the collaborator explore, and then judge the result through actual use.

That freedom comes with responsibility. An implementation that compiles is not necessarily reliable. A feature that looks impressive in a demonstration may be frustrating in practice. An automated test can’t reproduce every condition of a real project. And a suggestion from an AI collaborator isn’t automatically a good product decision.

I still need to understand what is being built, what it assumes, and where it might fail. The difference is that testing an idea no longer means committing weeks of effort before finding out whether it was worthwhile.

Not Everything Needs to Become a Product

Being able to build software this quickly brings another temptation. Once something works, it’s easy to imagine everything it could become: more features, more platforms, more integrations, a commercial release, an entire ecosystem.

Some of those ideas may eventually be worthwhile. But I don’t think every inconvenience I solve needs to become a business.

Tack is valuable because it helps me manage my attention. Sheetwall is valuable because it makes navigating drawings less frustrating. MarkUpX is valuable because it lets me communicate something visually without unnecessary preparation.

Those are sufficient reasons for them to exist. If other people find them useful, that’s encouraging. If they grow into something larger, I’ll evaluate that when there’s a reason to.

For now, I want to avoid confusing the ability to build something with a responsibility to keep expanding it. One of the harder decisions may be knowing when a tool is already doing enough.

The Friction We Stop Noticing

In an earlier entry, The Coordinator’s Brain Should Not Be the Project’s Database, I wrote about keeping a project’s coordination history in one person’s memory. That led me to build b1m.solutions, a place to retain the thread around issues, decisions and unanswered questions.

Looking at Tack, MarkUpX and Sheetwall, I can see the same pattern. Each one is something I had been carrying myself, the history of a project, a small intention, a point I needed to show someone, a sheet I knew existed, and that a tool could carry better.

None of them began with an ambition to build a collection of software. They began with ordinary frustrations that I had treated as unavoidable, because the work was still getting done. I could find the drawing. I could remember the task. I could annotate the screenshot. I could reconstruct the history of an issue.

So I kept doing those things. It took a change in what was possible for me to start questioning whether I needed to keep doing them the same way.

I don’t think every frustration needs a custom application. Quite often, improving an existing process or learning to use an existing tool properly is the better answer. But I’ve become more attentive to the difference between work that is inherently difficult and work that has become difficult because of the tools and habits surrounding it.

Engineering coordination will always require judgement, interpretation, communication and the occasional uncomfortable decision. I don’t expect software to eliminate those responsibilities, and I wouldn’t want it to.

What I want to eliminate is the unnecessary effort that accumulates around them. The repeated searches. The forgotten intentions. The extra steps between seeing a problem and communicating it. The information that exists but takes too long to retrieve.

Individually, these things are easy to dismiss. Over months and years, they become part of how we work. And eventually, we stop noticing them.

The work was getting done. I had simply stopped asking how much of the effort was actually necessary.