Building Simply.ClipboardMonitor: A clipboard inspection tool

Dmitry Bakuntsev — Sat, 28 Mar 2026 19:00:19 +0000

TL;DR

I built a small WPF utility to inspect exactly what applications put on the Windows clipboard, and along the way used it as a low-risk experiment in developing a real tool almost entirely with LLM-generated code.

Background

So, I've been trying to get started freelancing on Upwork.

Back in the eLance days, I had an approach that worked well for winning projects and keeping clients satisfied. For a well-defined fixed-fee project, I would create a functional prototype, estimate the total time, multiply it by my hourly rate, and submit a proposal together with a recorded video demonstrating the prototype. The success rate was fairly high; only once or twice was a proposal rejected due to high price. The demo videos were always watched, and sometimes more than once.

That approach did require an upfront investment of time - a few hours, maybe a day, and once an entire week for an Eclipse plug-in. However, eLance projects had proposal submission deadlines, and clients generally waited until those deadlines passed before selecting a freelancer, which made this strategy viable.

Fast forward to the present day. I registered on Upwork with the intention of reusing the same strategy to draw attention by demonstrating actual progress on the requested work, despite having no rating on the platform. That approach did not work. Freelancer selection on Upwork seems to happen quickly, so submitting a proposal even a day after a job is posted is often a waste of time - and money, given how proposals require “connects” on Upwork. My proposals were rarely opened, and more frustratingly, none of the demo videos I recorded were watched.

This leads to one particular project on Upwork. A client requested the creation of a (fairly well-defined) Windows 11 utility that would detect clipboard content changes, maintain a history of those changes, and allow the user to paste from that history into the active application. The implementation was required to use WPF. The request was somewhat unusual, given that Windows 11 already provides built-in clipboard history functionality, but the client indicated that additional productivity utilities would likely follow for the successful freelancer.

I pursued this opportunity using the same process: create a prototype, record a short demo video, write a detailed proposal, and include the video link in the first sentence. Completing this took one full day. I priced the proposal at 33% below the client's estimated fixed fee and used additional Upwork “connects” so that it would appear near the top of the list. It didn't matter. The proposal was never opened. The video was never watched. A day later, the project was awarded to someone else.

That's when I thought: why not turn this into something useful anyway? If a random stranger is willing to pay good money for this utility, then surely someone else will find it useful too - assuming any market research was done at all. So instead of shelving the code, why not turn it into a small FOSS project?

Development

This project served as a small, contained experiment in using Claude Code for end-to-end development. With the exception of some minor tweaks, all of the source code was generated or refactored by Claude. Manual editing was kept deliberately minimal.

The initial prototype was intentionally small in scope: a WPF application capable of listening for clipboard changes, enumerating available clipboard formats, and rendering basic preview panes for supported content types. At this stage, only basic requirements were defined, along with a set of design guidelines. These were provided to Claude and effectively acted as a lightweight specification.

As development progressed and additional features were introduced, the limitations of this minimal specification became more apparent. In several cases, implementing a new feature required multiple rounds of increasingly detailed instructions to compensate for missing context or underspecified behavior. Each iteration clarified assumptions, edge cases, or expected interactions that had not been captured initially. While the generated code often appeared reasonable at first glance, incorrect assumptions or design choices frequently emerged once the feature was exercised more thoroughly.

Working in small iterations proved essential. Keeping individual pieces of functionality narrow and self-contained made it significantly easier to validate behavior and correct mistakes early. In contrast, attempts (on other experiments) to generate complete applications directly from a requirements or specification document often resulted in software that was impossible to use and very difficult to fix once incorrect design decisions had been baked in.

Overall, the experience reinforced a recurring pattern: LLM-based code generation is highly effective at producing large volumes of plausible code, but the quality of the result depends heavily on the precision of the constraints it operates under. Clear requirements, explicit design intent, and incremental development all become more important - not less - when most of the code is written by a model.

What the Utility Does

The idea behind Simply.ClipboardMonitor is straightforward: make clipboard activity visible.

Modern Windows applications rarely place a single representation of data onto the clipboard. Even something as simple as copying a block of text typically results in multiple clipboard formats being populated at once - plain text, Unicode text, rich text, and sometimes application-specific formats as well. Normally, all of this happens invisibly.

This utility exposes that behavior directly. It listens for clipboard changes and captures each update as a snapshot, allowing inspection of the formats present at that moment and the data associated with each one. The goal is not to replace Windows' built-in clipboard history, but to provide a tool that helps answer the question: what exactly did this application put on the clipboard?

At a minimum, the application shows:

Every clipboard format present after a change
Basic metadata about each format
A set of preview panes for formats that can be reasonably decoded or rendered

For textual content, the data can be viewed in decoded form. For images and other visual formats, an image preview is shown. Binary or unfamiliar formats are still exposed, even if no higher-level rendering is available, making it clear that the data exists even when it cannot be meaningfully interpreted.

The utility is intended to be used as an inspection tool running in the background. It can remain active while you interact with other applications, quietly recording clipboard changes and making them available for later examination. This makes it particularly useful when debugging clipboard interactions or trying to understand how a third-party application represents copied data internally.

Features and Structure

At its current stage, Simply.ClipboardMonitor focuses on inspection rather than automation or transformation. The feature set reflects that goal and is intentionally narrow.

Clipboard monitoring

The application registers as a clipboard listener and reacts to every clipboard update. Each change is captured as a discrete snapshot, preserving the state of the clipboard at that point in time. These snapshots form the basis for all further inspection and preview functionality.

Rather than attempting to interpret a single “primary” clipboard representation, the utility treats every available format as first-class data. This makes it easier to spot unexpected formats or data that applications quietly include alongside the obvious ones.

Format enumeration and metadata

For each snapshot, the application displays the complete list of clipboard formats present after the update. Alongside the format identifiers, basic metadata is shown to give a quick indication of what kind of data is involved and how large it is.

This view alone is often sufficient to answer simple questions - such as whether an application provides rich text, embeds images, or includes private or application-specific formats that are not immediately apparent.

Preview panes

Where possible, the utility attempts to render clipboard data in a human-readable form.

Text formats are decoded and shown as text, making it easy to compare how the same data appears across different encodings or representations. For image-based formats, an image preview is displayed. For formats that cannot be meaningfully interpreted, the data is still surfaced, even if only in raw or binary form.

The intent here is not to handle every possible clipboard format gracefully, but to make it clear what exists, even when a higher-level representation is not available.

Running in the background

Simply.ClipboardMonitor is designed to stay out of the way. It can run minimized while other applications are in use, quietly collecting clipboard snapshots in the background. You can then inspect clipboard activity after the fact, without having to keep the tool in focus while reproducing a problem or experimenting with another application.

GitHub Repository

For anyone interested in trying it out or exploring the code, the GitHub repository is available at:

https://github.com/dbakuntsev/simply.clipboard-monitor

DEV Community: Dmitry Bakuntsev