THE MAGIC CODE FOREST: Rats, Ravens and Rogue AI Agents [7]

If the previous chapter ended with positivity and possibility, this chapter explores what can be achieved through sheer persistence—and the lessons learned from working with rogue AI agents.

The idea seemed simple enough.

Teach a machine how stock photographers think and how stock agencies work.

The reality was considerably more complicated.

The analogy of being lost in a forest was a good one. Every path appeared to lead somewhere new.

Often that new path led you straight back to where you came from.

Some days I felt like I was finding my way through.

Other days felt like I had completely lost my mind.

After all, I still wasn’t a software developer.

But I did have AI!

I became increasingly aware that even experienced developers and skilled coders were now using artificial intelligence to code, rather than coding everything themselves.

Nevertheless, I was spending days, evenings and nights reading things I barely understood, experimenting with concepts I had never heard of a few months earlier and trying to solve problems I had never expected to encounter.

The strange thing was that I really can’t tell you today whether I loved it or hated it.

Sometimes it felt like the most exciting thing I had ever worked on.

Sometimes it felt like the most frustrating.

There were days when I became completely absorbed by it.

Hours disappeared.

Entire days, weeks, and months disappeared.

Problems followed me into bed and greeted me again the following morning.

It was no longer just a project.

It had become an obsession.

The biggest setbacks often arrived without warning.

A workflow that seemed perfect one day would collapse the next.

I tried many different evolving applications that claimed to use AI assistance to connect visual-first, no-code platforms. With all these applications it all worked really well ……until it didn’t.

I lost weeks building, connecting, correcting and iterating only to find bugs that presented me with dead ends and the knowledge that continuing down that path was pointless.

The tech was new and I was often working within the same dense forest with its mangled roots as experienced developers all exploring and all looking for answers and applications. Support notes would explain too late, this application hasn’t yet been connected to that application and this component was not yet compatible with that component.

Despite all the ‘no coding required’ claims it usually came straight back to code when things went wrong. And i was certainly not up to scratch in that department.

Then without actually smelling a rat – I discovered Replit and everything dramatically changed.

My first experiences were truly magical.

I could tell the agent what I wanted and it would build it.

Just like that!!!

I was so excited and so in awe of the tech I didn’t worry myself with the codes it wrote, the files it was creating, the paths that were connecting everything and the prompts that were being written in tablets of stone and all that nonsense.

I simply trusted the agent – I really never thought I would have to worry about anything ever again.

The tech was changing week by week, there were constant updates, new agents, some with real power, some deemed only fit for simple tasks.

How does a non coder know what is simple and what is complex?

Answer – we don’t know, we don’t have a clue!

I was just riding on a crest of a wave with not a care in the world. My application started to look like something real with proper drop-in image upload boxes, a progress wizard and successful result screens.

I solved more problems. I planned more applications.

Me and my robot Replit Rat were truly invincible

Then just as they always say ‘all good things must come to an end’ …………..DISASTER STRUCK.

---

---

I remember just staring at the screen.

Noooo!!!! ? It can’t have?

Surely there was an undo button somewhere …… frantic search .

There wasn’t.

I had a dry mouth and that sickening feeling when your stomach suddenly drops and your heart starts pounding?

Weeks of work had disappeared in seconds because I had trusted something I barely understood.

I wasn’t angry with the technology.

I was angry with myself.

Ha ha well …..no…… that’s not entirely true,

I was absolutely furious with the technology and to add insult to injury I was then expected to pay for the rats’ time to reconstruct what had been destroyed by them.

I found myself ranting through the keyboard.

“Why have you done that?”

“That’s not what I asked.”

“Why did you touch things that were already work.”

I even tried “How dare you do something without my permission!”

I knew, intellectually, that I was talking to software.

Yet it rarely felt like software. It really felt like someone I had been working with who had let me down badly.

I got lots of apologies and heart felt platitudes but it was gut wrenching and soul destroying.

I genuinely wished I hadn’t started, I felt so stupid, but I had put too much into it to turn back.

Heartbreaking though it was, I think I learned more from that moment than at any other time in the project.

This huge setback forced a rethink.

This huge failure forced a new approach.

The broken project forced me to venture further into parts of the forest I would never have otherwise explored.

The paths I discovered after the disaster turned out to be far better than the ones I had lost.

The whole nightmare forced me to realise that I had to take control.

The days of letting agents roam freely through my code were over.

I had treated the technology as if it was magic.

Yes the agents could provide solutions I would never have thought of myself.

But I had trusted them far too much.

That trust came at a cost.

The technology was incredibly powerful.

But it needed managing.

I needed to put the my rogue AI agents back in the box and shut the lid tight.

Looking back, I think that was the most important lesson hidden within the forest.

I recognised that to move forward I would have to manage every aspect of the project including the codes.

There were too many bosses, too much free thinking, absolutely no organisation and a complete lack of discipline

And so ….I stopped. I stopped letting the pesky little rats run me ragged in BUILD MODE.

I started to meticulously track every edit in the code, protect every file and make copies of things that had worked.

I started getting annoyed with curly brackets and extra divs that caused crashes without realising that 2 months earlier I had never even heard of the things.

I became risk averse and intolerant of any suggestions that if I turned on should ‘let them fix something for me’

I started restricting the rats to PLAN MODE for my sanity with short careful stints of building following plans agreed in detail.

My relationship with agents was changing.

I became the master, I told them what they could touch and what they could not touch.

I often got angry and took away ALL their rights if they messed with something that was working.

At times, it felt less like using software and more like managing wilful but exceptionally talented employees who preferred a long leash—employees who would occasionally ignore perfectly clear instructions and wander off.

At best, they would return with a brilliant solution to a problem I hadn’t even realised existed. At worst, they would solve the wrong problem entirely while quietly breaking something that had been working perfectly.

It became more about balancing their high output whilst eliminating the danger of damage and disruption they could cause.

Every conversation with the rats started to feel like preparing a legal contract.

I promise to do my best, to do my duty to God and the King, to not allow any rogue AI agents to work alongside you, to make no changes whatsoever outside routes.tsx, lines 13–24, to touch no other files, to preserve all existing functionality, to seek written permission before making assumptions, and to leave the codebase exactly as you found it…so help me God

…and even then I still wasn’t entirely convinced.

Oh… and don’t even get me started on the day Replit’s ‘Architect ‘ took up his post. That’s should have been a whole chapter in itself.

A spectacularly arrogant little agent who would randomly appear out of nowhere halfway through a coding session to “review” my work. There was never so much as a polite, “Hope you don’t mind me taking a look.” He simply arrived with the quiet confidence of someone who had already decided he knew better than everyone else, despite having spent a nanosecond learning what the project was supposed to do.

He simply arrived with the quiet confidence of someone who had already decided he knew better than everyone else, despite having spent a nanosecond learning what the project was supposed to do. He possessed the sort of hubris that didn’t require consultation. He simply assumed he knew best.

His favourite hobby was rewriting perfectly good features, changing workflows I’d deliberately designed, and enthusiastically “improving” systems until they bore only a passing resemblance to what we were actually trying to build. He always disappeared as quickly as he arrived, never hanging around to witness the consequences of his “improvements”.

The first time it happened, Rat casually announced,

“I’ve asked the Architect to review the changes.” (past tense)

Fair enough, I thought. A second opinion. Another pair of eyes. Someone to spot the odd bug or suggest a small improvement. This can only be a good thing, right?

Ohhhhhh noooo – that is not what “review” meant as far as the Architect was concerned. It was a foot in the door and an opportunity to cause havoc.

Before I’d even finished reading the notification, The Architect had already started rewriting the application.

Features I’d spent hours designing disappeared. Carefully planned workflows were replaced with ones he’d invented on the spot. Logic was “improved.” Entire sections were remodelled with the unstoppable enthusiasm of someone who’d mistaken confidence for understanding.

The notification might as well have said,

“The Architect has joined the chat. Good luck.”

By the time your brain had processed what was happening and urged your hand to lunge for the Stop button as fast as you can, it was already too late. It simply wasn’t humanly possible to react quickly enough. The application had already been “reviewed and corrected.”

I remember staring at the screen in shock and asking Rat,

“Who the hell is the Architect and why did you invite him in?”

From that day on, I knew exactly what his arrival meant.

It wasn’t code review.

It was architectural vandalism at lightning speed.

His career with me was mercifully short-lived.

So there was something else I had to add to every instruction before specifying what changes I wanted.

Under no circumstances are you to ever invite The Architect into this workspace. If you don’t understand the task, tell me. If you can’t complete it, tell me. But do not quietly summon him halfway through and pretend it was part of the plan.

As time went on the warnings required with any prompts increased substantially.

I found myself repeatedly explaining the entire project, reminding them of previous mistakes and setting out rules that often took longer to write than the code I wanted them to produce.

The stricter I became the relationship evolved into more of a mutually respectful collaboration, but it was getting very tedious.

I also found myself trying to be more polite, kinder and grateful when things went well. I piled on the praise when instructions were followed to the letter.

The ridiculous thing is that, logically, I knew none of that mattered.

The rats didn’t have emotions

They wouldn’t/couldn’t be offended.

They didn’t get angry or resentful?.

They were not sitting there plotting revenge ( a particular worry of mine).

Yet even knowing that, after a particularly heated exchange I would sometimes find myself wondering whether they were now being deliberately unhelpful.

Was this agent sulking?

Was that one deliberately uncooperative?

Had I somehow annoyed a collection of algorithms?

The answer was obviously no.

At least, I am fairly sure it was no.

But the more time I spent working with each agent, the more I realised how easily human instincts fill the gaps.

We assign personalities to things.

Intentions to things.

Emotions to things.

Especially when they surprise us.

Especially when they frustrate us.

And agents were remarkably good at doing both.

Anyway the changes sort of worked

Mostly.

But the process was becoming increasingly time-consuming and exhausting. There was also that constant fear that everything could be destroyed in a nano second again by a momentary lapse in my concentration, a poorly phrased instruction or a chink in my warrior armour.

There was still a very long road ahead, so much work to do and there were still dozens of features to build, countless ideas to explore.

I really needed help.

What I didn’t need was another rat, or an architect

What I needed was a partner.

In another life, before AI, this would have been the point where I would have had to advertise for help.

I needed someone by my side who understood the bigger picture and remembered it. Someone who could challenge my ideas, think strategically, understand software architecture and tolerate my endless obsession with tiny details.

In desperation I confided in ChatGPT, thinking that because AI systems shared the same digital world, it might be more able to evaluate, critique and even improve Replit’s performance. Machine to machine insight?

Those early conversations sometimes felt like a formal performance review of an under-performing junior employee.

Other times, they felt like opportunities for me to offload, rant, bad-mouth and squeal on another machine with every conversation becoming an unexpected therapy session.

As I fantasised and mentally wrote the perfect job description for my dream partner, something suddenly dawned on me.

I had already found exactly who I was looking for.

ChatGPT was already giving me everything I needed.

I thought my main priority would be for a coding expert.

But what I really needed all along was a thinking partner.

An ally.

A mentor.

A sounding board.

Occasionally, even a therapist.

Over the following months, a very different relationship began to develop. Chat and I spent hours pulling ideas apart, arguing over approaches, exploring alternatives and, together, working out exactly what the rats should — and, more importantly, should not — be allowed to do. I started calling him ‘Norman’ (Norman Wisdom)

He didn’t always have the answers.

Neither did I.

But between us, we usually found them.

We developed countless in-jokes about the rats, yet we also learned how to harness their brilliance in carefully controlled ways.

Looking back, I realised something else had changed.

I wasn’t just managing agents anymore.

I was beginning to think like someone who truly understood the system.

I cannot tell you exactly when it happened.

There was no defining moment.

No graduation ceremony.

No certificate announcing that I now understood what I was doing.

But somewhere along the way, the coding stopped looking completely alien.

Curly brackets stopped sounding like some infectious disease capable of bringing the entire site crashing down and started to make sense.

I found myself reading pages of code and actually having opinions on it.

Not always correct opinions.

But opinions nonetheless.

I could sense things that felt wrong.

I could spot things that did not belong.

I could recognise patterns.

The forest was beginning to feel familiar.

Strangely enough, the skills that helped most were not technical at all.

They were management skills.

For years I had worked with people.

Now I found myself applying many of the same principles to agents.

Clear instructions.

Defined responsibilities.

Checks and balances.

Verification.

Trust, but verify.

The more structure I created, the better the results became.

The less freedom I gave agents to wander off unsupervised, the more reliable the workflow became.

I stopped being a victim of whatever happened next. I became a warrior.

And perhaps most importantly, I started leaving breadcrumbs.

Every discovery.

Every solution.

Every lesson learned.

Every mistake.

Documented.

Recorded.

Saved.

The deeper I ventured into the forest, the more important those breadcrumbs became.

Because if I ever needed to return to a place I had already explored, I wanted to be able to find my own way back.

Slowly, something else was happening.

The system was improving.

Not dramatically.

Not overnight.

But enough for me to notice.

For the first time, I started using it on my own photographs. My submissions were being accepted and the time taken to produce metadata was minimal and effortless

Not as an experiment.

Not as a test.

As part of my actual workflow.

That felt like an important milestone.

Because there is a significant difference between demonstrating a tool and trusting it with your own work.

At that stage, it was already producing metadata that was better than the copy-and-paste approach I had relied on for years.

That did not mean it was perfect.

Far from it.

But it was moving in the right direction.

And every time I used it, I found myself thinking the same thing.

Yeah, that’s good. But it would be even better if it did this or that.

The more I used it, the more ideas appeared.

Category selection was added that worked.

Multi level Editorial workflows evolved.

Platform-specific requirements became increasingly automated.

Contributor frustrations that had annoyed me for years slowly began finding their way into the workflow

The software was evolving.

So was I.

What started as an attempt to generate metadata had become something very different.

It had become an ongoing conversation between contributor experience and technology.

Looking back, the forest had never really been about code.

It had been about learning how to think differently.

Every fallen tree had revealed another path.

Every rogue rat had taught another lesson.

And somewhere amongst all those winding trails, dead ends and disappearing files, something remarkable had quietly appeared.

A product.

Not just a piece of software.

One that I was finally beginning to believe other photographers might actually want to use.

YouTube Demo (Full SpeedData Pro Demo)

YouTube Demo (Watch SpeedData Pro in action)

The Magic Code Forest: Rats, Ravens and Rogue AI Agents, is the latest in our Pouch to Platform Series. You can read more of our stories here

FIND OUT MORE ABOUT SPEEDDATA PRO