My experiments with Claude go back to at least early 2024, within a wider exploration that also includes ChatGPT and Gemini. What began with conversations in a chat window has grown into building software, working across business systems and developing methods I can reuse.
Over the past year, that has become a much bigger part of everyday work. I'm using Claude Projects for context, Claude Code for hands-on work in repositories, and Cowork with connections to business systems such as Xero, HubSpot and Notion. Reusable skills and MCP servers are part of that work too.
The interesting thread is how those pieces fit together: turn an idea into something concrete, inspect it, improve it, then keep enough of the method that the next task can start further along.
Building with Claude Code
I've been using Claude Code on website implementation and working with Claude-assisted development across applications and tools. My website briefs have asked for changes that can be inspected on a branch or preview, with existing work preserved and unresolved decisions called out.
That makes the brief important. What are we trying to change? Which parts are already agreed? What must stay intact? What should be checked before the result comes back?
The useful output is a reviewable change: the implementation, a preview where appropriate, checks and a clear account of what's left. Preparing that change and deciding to release it are separate responsibilities.
Keeping context usable
I've also been working with Claude Projects context while exploring how Claude and ChatGPT can draw on a shared set of current information. Separate project memories can be convenient, but they can also leave different tools working from different versions of the same story.
The direction I'm working towards is a clear place for the current decisions and source material, with enough context carried into each task. A long conversation isn't a substitute for knowing which decision still stands.
Turning useful methods into skills
The reusable-skill work is a significant part of this. Within Measurelab's Toolkit, Claude Code has been used to develop and refactor skills, package reference material and scripts, and add validation. This is team work, and my role includes shaping the work and reviewing what comes back.
The examples span document editing, reviews and workflows that separate preparation from actions requiring approval. A good skill needs to explain its inputs, source material, boundaries and checks, as well as the steps to follow.
The SEAM journey is connected to this: separating definitions of what things mean from skills describing how to do the work, and making both available to agents. It deserves its own account.
I'm interested in whether that makes expertise easier to reuse and improve. It also creates maintenance work: instructions and references need to keep up with the systems they describe.
Outputs people can use
Claude Code also features in the work on published artefacts and in briefs for interactive explanations. That connects to a wider experiment in getting useful work out of the conversation: something another person can open, navigate, review and return to.
I've written more about that in Getting useful work out of the chat window.
Testing the boundaries
One smaller experiment was a local data-sanitisation pilot for Claude workflows, using synthetic data. It exposed the need to inspect both missed detections and false positives. Human review remained necessary.
The pilot stayed local and wasn't connected to Claude. It wasn't a production safeguard or permission to send private information to a model. The lesson was to keep data permissions, access and the limits of the test explicit.
What I'm trying to learn
Across all of this, the question is how to make useful work repeatable without hiding its assumptions. Can the next session pick up the right context? Can another person review the change? Can a skill be corrected when the underlying work changes?
Those are ongoing questions. Claude is already part of the practical work; the experiment is in making the surrounding methods clearer, more reusable and easier to trust.