TL;DR: I’ve been working with AI since 2017, before ChatGPT, before Cursor, before any of this was mainstream. This is the story of that journey: what I built, what I learned, and what I’d tell someone starting today.

This Isn’t a Resume

Let’s get something out of the way: I’m not looking for a job. This isn’t a LinkedIn CV.

This is an invitation. If you’re curious about AI, not sure where to start, or want to learn from someone who’s been at it for a while: I’m here to help.

Even today, I’m still learning. While everyone claims AI can do everything, I can see pitfalls that only become obvious with time and use.

The Enterprise Foundation

I’ll keep this brief because it’s not the point of the story, but it matters for context.

For nearly 20 years, I worked across enterprise technology: banking, telecom, and cloud infrastructure. I eventually became a CTO, leading large-scale infrastructure architecture and design for major enterprises. The kind of work that teaches you how systems actually behave under pressure.

But here’s the thing about climbing the ladder: you become disconnected from the code. My software engineering training from the late 90s was documentation-heavy, process-driven: CASE tools, waterfall, specifications before code. Then Agile came. Then DevOps. As a technologist, we learn with the times. I adopted modern practices like everyone else.

But that old training? It formed a foundation of who I am today. I just didn’t know how relevant it would become.

The Fork Moment: Christmas 2017

In 2017, I was in a CTO role at a cloud infrastructure company. AI wasn’t my job. It was my side hustle. A hobby. Something I tinkered with after hours because I was curious.

I felt behind in code. I wanted to learn Python. And I’d been hearing about this thing called machine learning.

That Christmas break, I started my first real ML project: a Twitter sentiment analyser for Bitcoin. The files from those first few days (December 25-27, 2017) are still sitting in a folder. They mark the beginning, not the end.

Learning NLTK, understanding how classifiers work, figuring out Twitter’s streaming API: that took months, not days. I trained an ensemble of six classifiers. Built a real-time NLP pipeline. Iterated through multiple versions. Each step taught me something new about how ML systems actually work.

Looking back, the code is almost quaint now: Python 3.5, the deprecated StreamListener pattern, Twitter API v1.1. But that project got me started.

The important thing: there was no ChatGPT. No Cursor. No AI tutor to help. I had to write the code myself, follow tutorials, read documentation, ask questions in forums. Learn by doing.

That Christmas 2017 project was the spark. For the next five years (2017 to 2022) I kept at it. FreqTrade cryptocurrency bots. Data pipelines. Reinforcement learning concepts. Each project building on what I’d learned before.

Back then, AI moved at the same pace as any other technology. You learned a framework, it stayed relevant for years. You could take your time. The explosive acceleration we see today simply didn’t exist yet.

November 30, 2022: The Explosion

Then ChatGPT launched.

I remember the feeling: this is amazing. It can do things. It can find things. It can try things out. It can work up patterns.

After years of grinding through documentation and templates, suddenly I had a private tutor. I could prototype one approach, build a model, test it. Prototype another. Test it. An explosion of capability and learning.

What happened over the next three years moved fast:

At each step, I was there. Adopting. Learning. Building.

The Acceleration: March-August 2023

With ChatGPT as my tutor, I went deep. Really deep.

March 2023: I threw myself into reinforcement learning for cryptocurrency trading. Custom reward functions. Feature engineering with RSI, MFI, momentum indicators. Tensorboard for training visualisation. Six iterations of trading strategies in a single month.

I built my own RL environment from scratch. Designed reward functions that balanced profit against risk. Trained classifiers using XGBoost multi-target regression. Integrated GPT into trading decision pipelines.

What did I learn? Which technical indicators actually matter. How to iterate quickly. How to fail fast and move on. By July, I was integrating GPT into trading decision pipelines.

This wasn’t playing around. This was learning how AI systems actually work: from reward design to feature selection to model training to production deployment.

Finding My Stride: Late 2024

With Cursor and Claude as collaborators, I started building real applications. Not tutorials. Not toy projects. Real tools solving real problems.

September 2024: I connected AI to enterprise cloud infrastructure, building interfaces that could actually manage production workloads. This was new territory: AI systems that needed to be reliable, not just impressive.

October 2024: YouTube analysis platforms with real-time processing. I wanted to understand how AI could handle streaming data at scale. More lessons in what works and what doesn’t.

November 2024: MCP Protocol launched. I adopted it within weeks.

This was a turning point. MCP gave AI systems a standardised way to interact with external tools. I built safety-first file operations after watching AI accidentally delete my Obsidian notes one too many times. Lesson learned: AI needs guardrails.

December 2024: More MCP servers. Enterprise cloud integration. Agent orchestration patterns. Each project validated an idea or taught me why it didn’t work.

This was rapid experimentation. Try something. See if it works. Learn. Move on. The pace was different from the 2017-2022 era. Now I could prototype in hours what would have taken weeks.

The Memory Bank: Going Back to My Roots

When Cursor came out, something clicked.

I saw a gist talking about a “memory bank” used in Cline. That got me thinking: I could use Cursor rules and add my own twist to it.

My twist? Process. Not just code, process.

I went back to my waterfall roots. Graphs to maximise context. Structured documentation. Specifications that told the AI exactly what it needed to know.

The result was cursor-memory-bank. Almost 3,000 stars now. Over 400 forks.

Why did it resonate? Because people needed process. AI was getting off track. People didn’t know how to document. They couldn’t write specifications, which meant they couldn’t give the right information to the AI, which meant the AI produced garbage.

I didn’t have the tools we have today. I just hoped a graph would suffice. But the principle was right.

Notice that phrase: progressively disclose. That’s now how skills work in Claude Code. Not in a graph like I did, but the agents are trained to look for context and drill down further. The same problem, different implementations.

The Old School Advantage

Nobody saw this coming: old-school software engineering principles are returning.

In 1994, the SEI (Software Engineering Institute) curriculum dedicated 29% of coursework to Software Process: requirements, specifications, design, verification. The whole philosophy was: “The precise use of formal notations and words is necessary to express them with a degree of precision meaningful to other engineers.”

Then RAD came. Then Agile. “Code is self-documenting” became the mantra. Specifications were seen as waterfall relics.

But then AI arrived.

And it turns out: specifications were never obsolete. They just fell out of fashion because humans could maintain mental models, incorporate tacit knowledge, and adapt on the fly. When the implementer is an AI system, precision and explicitness become critical again.

The University of Washington said it clearly in 2025:

“Coding, or the translation of a precise design into software instructions, is dead. AI can do that. We have never graduated coders. We have always graduated software engineers.”

The workflow has shifted:

Old: Requirements → Design → Manual Coding → Testing
New: Requirements → Detailed Specification → AI Code Generation → Validation

That training I thought was outdated for 20 years? Suddenly the most relevant skillset for AI-assisted development.

2025: The Explosion of Creation

By 2025, everything came together. The skills I’d built across eight years (sentiment analysis, reinforcement learning, enterprise integration, process engineering) suddenly had outlets.

March 2025: cursor-memory-bank launched. It took off faster than I expected.

May 2025: Claude Code tools for file organisation, intelligent agents, background processing.

June 2025: MCP servers for enterprise cloud platforms. Agent collectives with hub-and-spoke coordination. A markdown viewer because I needed a way to share AI outputs with non-technical staff, and if you don’t have something and don’t want to pay for it, you can just build it.

July 2025: Automatic git history management. Never write commit messages again.

October 2025: CLI tooling. Desktop applications. Voice integration.

November 2025: Agent SDK development. Custom LLM work.

Each project building on the last. Each tool solving a real problem I’d encountered. The thread throughout: process, documentation, structure, applied to AI development.

Why Open Source?

I’d always been in private and enterprise, where we don’t share anything, afraid of people stealing ideas.

I wanted to try something different. Let the world take it. Let them learn from it. Let them benefit.

The forks on cursor-memory-bank represent people who took the idea, iterated on it, built greater things. I’ll never see most of what they created. But that’s the ripple effect. That’s the point.

Giving has a different feeling than taking.

What I’m Still Learning

Even today, I’m not comfortable.

While everyone claims AI can do everything, I can see pitfalls that only become obvious with time and use. The SDKs being developed (the harnesses to the wild AI model horses, so to speak) are overlooked. People don’t realise the control you can get. The determinism.

You can control everything. You can have an agent in the loop. You can have specific requirements. But most people expect things to get done for them. It doesn’t work that easy.

You still need to think. Problem solve. Understand how things work.

With AI, this wasn’t any different. The difference was the ability to turn those ideas around faster, and yes, document them easily.

The Invitation

This post isn’t a job application. It’s an offer.

If you’re where I was in 2017, curious about AI, not sure where to start, my advice:

1. Find something you’re passionate about. Let AI help you forge a path.

2. Ask AI when you’re not sure. As we’ve grown up, we’ve learned how to navigate around not being able to do certain things. AI allows you to not navigate, to ask directly.

3. Change your mindset. Once you do that, it opens all kinds of doors.

4. Do the work. Learning and researching is part of the journey. Being given something at the end without this effort, to me at least, does not feel as fruitful.

5. Participate. Even if you know others will eventually solve it. The process matters.

I love teaching people. I love helping people. I’ve done many pro bono projects not asking for anything in return.

If any of this resonates, reach out. I’m always happy to chat.

Where to Find My Work

From that first Christmas 2017 project through to today, the pattern is consistent: learn by doing, share what works, iterate.

The Foundations:

• cursor-memory-bank: The framework that brought waterfall-era discipline to 2024 AI.
• claude-code-sub-agent-collective: Context engineering research with hub-and-spoke agent coordination.

The Tools:

• atomic-writer-mcp: Safety-first file operations for AI. Built after watching AI accidentally delete content one too many times.
• Claude-Code-MindPalace: Never write commit messages again. Auto-checkpoint every change.
• cline.code: OpenAI-compatible bridge letting Cline use Claude Code via MCP.
• cloudstack-mcp-server: Enterprise cloud infrastructure meets AI.

The Ongoing:

• This blog: Where I share what I’m learning.

The journey continues. I hope you’ll join me.

Genuine interest? Reach out via the links in the footer.