"I'll Never Use AI": An Observation on Everyday Tech Hypocrisy

Time for a rant. Well, not really a rant - more of an observation on the hypocrisy, or at least the ignorance, of how people view modern technology.

As my research is currently based firmly in artificial intelligence - all aspects of it, not just generative AI - I often hear people say with absolute conviction:

"I don't like AI. I'll never use it."

Fair enough. Don't use it then.

But if you are truly committing to an AI-free lifestyle, you're going to have to give up a few things...

The "I Don't Use AI" Starter Pack

So, you want to avoid AI? Here is what you need to stop doing today:

• Give up your phone. Autocorrect, spelling checkers, search engines, and even those neat photo and video clean-up features all use artificial intelligence.
• Stop using the internet. Most, if not all, of the major search engines use AI to find you the best results.
• Learn the language before going abroad. Translator apps are only as good as they are because of generative AI.
• Stop video conferencing. Do you like the automatic transcripts in Teams or Zoom? Guess what? That's AI doing the work for you.
• Stop using your credit card. Fraud has become such a minefield these days that the only way credit companies can keep up and keep your transactions safe is with AI-powered fraud detection.
• Ditch the digital maps. Not sure how to get somewhere? Better find a physical paper map (if you can even find one). All the big map providers use AI to calculate the best route for you in real-time.
• Cancel your streaming subscriptions. Do you enjoy the recommendations from Netflix, Spotify, or Deezer? Better not use them anymore. Those recommendation engines are some of the most obvious machine learning algorithms out there.
• No more Ubers. Hailing a cab or getting the bus via an app? Uber and others use driver-matching algorithms and route optimisations, all based on AI.
• Unplug the smart speakers. This one should be obvious, but you will have to stop using Alexa, Siri, Google Assistant, and all the other digital assistants out there. I wanted to include this because I actually know people who claim they "hate AI" but use these smart speaker devices daily.

AI is Here to Stay (And Generative AI is Just the New Guy)

The point of this rant? AI is here to stay.

It has been in our lives for a lot longer than most people realise. Generative AI is only the new guy on the block. At the moment, it is still novel, and people are just discovering the best uses for it.

Now, do I agree with the way it's being used? Not entirely.

There need to be more guardrails in place. More testing in air-gapped sandboxes needs to happen. Right now, the big companies are trying to sprint without learning to tie their shoes first. At first, running like that feels great, but eventually, they will face-plant into the dirt.

How This Relates to My Work

How does this connect to my actual research? Well, I'm not trying to build the next ChatGPT or Claude. I'm not even sure I will go the route of language models (although I may have a crack at implementing one just to see).

My research, whilst originally about dreams, has evolved into looking at more efficient AI, safer AI, and - frankly - not trying to destroy the human race. I'm not in the race for ASI (Artificial Superintelligence) or even AGI (Artificial General Intelligence). I'm much more interested in making AI safer and drastically more efficient regarding power consumption.

Asimov was right in proposing the Three Laws of Robotics, even if it was in a body of fiction. The real problem is implementing them. Today, we call it the "alignment problem," but to me, that term is even more ambiguous than Asimov's laws.

The Bottom Line

I went a bit off track there, so back to the original topic.

Ultimately, AI is here, and it's not going away. It's here in the same way the steam engine came into our lives, or the same way the car became the norm. We need to accept it. But at the same time, tech companies need to take responsibility for coding (or, in my opinion, training) it to follow fundamental directives that absolutely cannot be overwritten.

Anyway, that's my view. I hope it made sense! Let me know your thoughts in the comments down below.

Killing the LSTM: Why DANI is Pivoting to a Spiking Neural Network

After some extensive research and a few hard encounters with hardware reality, I’ve made a major architectural decision regarding DANI's brain: I am completely ripping out the LSTM neural network and replacing it with a Recurrent Spiking Neural Network (RSNN).

Given my recent enthusiasm for the LSTM architecture, this will probably come as a surprise to anyone following along. However, I have my reasons, and as usual, they come down to math, metal, and thermal throttling.

What is wrong with LSTMs and the Traditional ANN?

Traditional Artificial Neural Networks (ANNs) are fantastic at what they were designed for: probability scoring. They allow us to simulate decision-making using massive matrix calculations mixed with a healthy dose of calculus.

But beneath the hood, they are brute-force mechanisms.

When a traditional ANN is fed data, that data cascades through every single neuron in the network. Even when a neuron has a zero value, the CPU still dutifully performs the mathematical operation of multiplying by zero. If a network has a shape of 10 inputs, 10 outputs, and 5 layers of 12 neurons each, that is 816 floating-point calculations just for one single feed-forward pass. If you start adding in simple recurrence, we are immediately up to 1,488 calculations.

Now, scale this up to something that would actually be useful for DANI. We need at least 100 inputs and about 64 outputs. With hidden layers of around 125 neurons each, we jump to 150,375 calculations per pass. To achieve an LSTM architecture, we can estimate the computation to be roughly four times that: over 600,000 calculations per tick.

As you can see, this grows exponentially. More importantly, it keeps the CPU running permanently hot. Don’t forget, DANI is powered by a Raspberry Pi 5. There is no GPU offloading here. I did manage to get DANI’s LSTM operating at 10Hz with 3.5 million parameters, but it required the Pi 5 to do absolutely nothing else, running flat-out at 100% utilization. DANI's brain was essentially doubling as a space heater, even when he was just "dreaming."

Once you add my simulated hormone system into the mix, the compute overhead goes up even further. I was basically following the same brute-force model that the big AI companies use, just without the luxury of a multi-million dollar server farm.

And then there is the training. To train an ANN of this style requires layer-by-layer calculus (backpropagation). This is heavy, blocking work. It takes a considerable amount of time, meaning we simply cannot train the network in real-time on anything substantial.

The Elegance of the Recurrent Spiking Neural Network

The architecture of an RSNN is topographically similar to other neural networks, but the execution is fundamentally different. It mimics biological reality much closer.

Instead of passing continuous floating-point numbers, each neuron has a membrane potential. As it receives signals from upstream neurons, that potential increases (or decreases, if the synapse is inhibitory). The neuron does absolutely nothing until that potential reaches a specific threshold. Once it hits the limit, it fires—or "spikes." And it spikes at a binary full power. The neuron then resets, either dropping to zero or subtracting the threshold from its current potential.

If a neuron doesn’t reach the threshold, it doesn’t spike. Period.

This means we only need to calculate the pathways for neurons that actually receive a spike. The computational reduction is staggering. The general consensus in the field is that for any given signal, only 5% to 10% of a spiking network is active, compared to the 100% density of a matrix-style network.

Training also becomes radically simpler. We only need to reinforce or weaken the synapses of the pathways that actually fired (a process akin to Spike-Timing-Dependent Plasticity). We apply a localized effector to those specific connections—no massive, network-wide calculus required.

But here is the real kicker for a systems engineer: an RSNN allows us to completely ditch floating-point math. By using integer mathematics and clever bit-shift operations (which are essentially free in terms of CPU cycles), we can completely bypass the messy, cycle-heavy floating-point multiplications.

How does this help DANI?

Obviously, DANI will not have to run so hot. If he has a quiet mind, the network will physically go quiet. When DANI rests, he will literally be saving power. By utilizing temporal calculations, we can also train him in real-time with near-zero impact on the system.

Furthermore, DANI’s brain becomes an event-driven architecture rather than a strict polling loop. Instead of processing rigidly on a timer, he will think and react in time with the world around him.

I will still be using the hormonal system I designed, but the key difference is how it integrates. The effective values of the hormones will now directly modulate the firing thresholds of the neurons. This allows his "moods" to physically alter the state of his brain and affect his behavior, even if his underlying memories remain unchanged.

I suppose I had better be nice to him.

Rethinking Asimov’s Laws

This pivot finally allows me to revisit a question I was pondering a while back: How do we encode Asimov’s Laws into an AI?

The answer is: we don’t. It’s as simple as that. We don’t hardcode the laws; we teach them.

By running an RSNN that learns in real-time through stimulus and reinforcement, the laws can become an emergent part of his personality. He will understand that hurting people is bad and that following human orders brings a reward, not because a line of code forces him to, but because his synapses have shaped themselves around those experiences.

So, I guess I really am going to have to be a parent to a robot.

Major Milestone: Skink Has Officially Bootstrapped!

Woohoo! It’s time for a long-overdue update on the language powering the future of DANI.

We just crossed a monumental threshold with Skink: it is now officially bootstrapped!

For anyone unfamiliar with compiler development, bootstrapping means that the Skink compiler can now compile its own source code. From here on out, all future versions of the Skink compiler will be written in Skink itself. It’s a huge rite of passage for any programming language project, and seeing it actually work after so much foundation work is insanely satisfying.

Where Go Fits In (For Now)

The handover

Now, does this mean I’m throwing Go out the window today? Not quite!

Go has a proven, rock-solid track record, and I’ll be keeping it around for prototyping work. Whenever I want to test out an idea quickly and I’m not sure if Skink is quite ready to handle the heavy lifting yet, Go gives me a reliable safety net.

However, the long-term vision hasn't changed: eventually, I plan to fully commit to Skink for almost all development across my projects, experiments, and research.

The Road to Skink 1.0

While bootstrapping is a massive step forward, we aren't quite at version 1.0 just yet. To earn that release tag, Skink needs to hit a few crucial targets:

1. Cross-Platform Support: Clean cross-compilation across Windows, macOS, and Linux.
2. Architecture Support: Full targeting for both x86 and ARM architectures.
3. Embedded Target Transpilation: The ability to compile (or at least transpile down) to low-power platforms like the K210, ESP32, and standard Arduino C/C++.
4. Direct Hardware I/O: First-class hardware abstraction libraries for lower-level protocols—specifically I2C, SPI, GPIO, and related interfaces.

Acceleration, Compute, and Graphics Backends

Beyond microcontrollers and standard CPUs, getting high-performance compute and neural inference support hooked up is high on the priority list.

• CUDA Support: I still need to get CUDA fully enabled and tested. Because of my current local setup, this will likely require either acquiring new dedicated NVIDIA hardware or setting up a cloud-based VM for build and test pipelines.
• 
  Vulkan & AMD: My main local system currently relies on Vulkan to run LM Studio, so a Vulkan compute backend is high on the radar as a viable cross-vendor path. I'm also looking closely at AMD’s libraries (ROCm/HIP) to ensure broad hardware compatibility.

It's a lot of moving parts, but watching the architecture take shape piece by piece is incredibly rewarding.

Bringing It Back to DANI

So, why go through all the trouble of building a custom language from scratch?

It all comes down to DANI. My goal has always been to have a single, unified language capable of bridging every layer of DANI’s stack—from high-level logic and neural compute all the way down to real-time bare-metal sensor and actuator control. Skink is the key to making that happen without juggling three different language ecosystems.

Speaking of DANI, there have also been some fascinating developments regarding his neural network architecture recently... but I’ll leave you hanging on that for now and save the deep dive for the next post!

Stay tuned!

Teaching an Old Bot New Tricks: A Reinforcement Learning Adventure

Alright, gather 'round, folks, because today we're talking about the secret sauce, the wizard behind the curtain, the... well, you get the idea. We're diving into Reinforcement Learning (RL)! If you've ever tried to teach a dog a new trick with treats, you've basically dabbled in the core concepts of RL. Except, in my case, the "dog" is a bunch of code and the "treats" are, well, also code. But way more rewarding, I promise!

Reinforcement Learning: Not Your Average Learning System

So, what is this voodoo? Reinforcement Learning is a type of machine learning where an agent (that's my AI, in this instance) learns to make decisions by interacting with an environment. Think of it as learning by trial and error, but on a rather epic scale. The agent takes an action, and the environment responds by giving it a reward (or a penalty, which is just a negative reward – like when you try to teach your cat to fetch and it just stares at you with disdain) and transitioning to a new state.

The whole point of this digital song and dance is for the agent to learn a policy. The policy is essentially the AI's brainy strategy guide, mapping states to actions. It tells the AI, "Okay, you're in this situation, so the best thing to do is that action." And "best" here means the action that's going to lead to the most cumulative reward over time. It’s not just about immediate gratification; RL is in it for the long haul, trying to maximize that sweet, sweet total reward. It's like choosing to eat a salad today so you can really enjoy that cake guilt-free later, but for robots.

Now, a crucial part of RL is the "exploration vs. exploitation" dilemma. Does the AI stick with what it knows works (exploit) to keep getting those reliable rewards, or does it try something new (explore) that might lead to an even bigger payoff, or, you know, a digital faceplant? It’s a bit like me deciding whether to order my usual at the local cafe or risk trying their "experimental new fusion dish." Thrills and spills, people!

RL: The Engine Driving My AI (and Keeping it From Marrying the Toaster)

Even an AI needs to experience consequences.

In my grand project to build an AI assistant – complete with a robot head and an ambition to not cause household chaos – RL is the star player. I want this AI to genuinely learn from its interactions with the world, not just follow a pre-programmed script.

Imagine the AI trying to navigate my workshop.

1. It takes an action: "roll forward a bit."
2. Environment update: "You've encountered a table leg. Oops."
3. Reward: "Minus 10 points, and you're now stuck."
4. New state: "Stuck."

Over many (many, many) such interactions, the RL algorithms will help the AI build a policy that says, "Approaching table-leg-like objects at this speed generally leads to a timeout in the corner. Avoid." This is how it learns to navigate, complete tasks, and hopefully, not declare war on the Roomba.

I'm even hoping to use RL to help the AI develop a rudimentary understanding of "emotions". Experiences that lead to "good" outcomes (positive rewards) could be tagged internally in a way that makes the AI "prefer" them, while "bad" outcomes (negative rewards) are discouraged. It’s not about making it feel sad when it bumps into the sofa, but about making it learn that bumping into the sofa is counterproductive to its goals.

Dreaming of Electric Sheep? More Like Dreaming of Better Algorithms!

Electric sheep?

This is where, for me, RL gets super exciting: powering my AI's dreams. I've been cooking up a system where the AI will have a sleep cycle with two main stages: NREM (for memory sorting – think digital decluttering) and REM (where the actual "dreaming" happens).

During REM sleep, the AI will pull up various memories – visual, audio, sensory, maybe even a simulated "emotion" if I can get that to work without it developing a sudden craving for actual electric sheep. It will then smush these together into a novel "dream scene". Here's the kicker: the AI will then have an internal "reaction" to this dream, and that reaction gets fed straight back into its reinforcement learning algorithms.

So, if the AI dreams it’s flying a kite made of toast (because why not?) and this scenario, through some abstract internal logic, is deemed "positive" or "insightful" by its own metrics, the RL system will reinforce the patterns or decisions within that dream. The memories involved get a score boost, and a new memory of the dream itself is created and logged. It's like the AI saying, "Hmm, toast-kites... interesting. Let's file that under 'potentially awesome ideas' or at least 'things that don't immediately result in a system crash'."

This allows the AI to explore scenarios, even utterly fantastical ones, and learn from them without the risk of, say, actually trying to make a kite out of toast in my kitchen. It’s a safe space for creative problem-solving and exploring the boundaries of its understanding, all guided and refined by RL.

Why RL is the Dream Team Captain

Doing a good job gets rewarded

Without RL, the AI's dreams might just be a bizarre slideshow of random data. Fun for a laugh, maybe, but not particularly useful. RL is what turns these digital night-ramblings into powerful learning opportunities. It’s the mechanism that allows the AI to:

Find Value in the Void: RL helps the AI figure out if a particular dream sequence, however abstract, offers some kind of useful information or a novel solution to a problem it's been mulling over.

Adapt and Overcome (Even in its Sleep): The "lessons" learned from a good (or bad) dream can then tweak its overall policy, making it better prepared for waking reality.

Strengthen What Matters: If certain memories or concepts repeatedly pop up in "successful" dreams, RL helps to reinforce their importance.

This means the AI isn't just passively experiencing dreams; it's actively learning from them, thanks to our good friend, Reinforcement Learning. It's the difference between your brain just replaying random snippets of your day and actually consolidating memories or working through problems while you snooze.

So, there you have it. RL is more than just a fancy algorithm; it's the core of my AI's ability to learn, adapt, and yes, even to dream productively. Now, if you'll excuse me, I need to go make sure my AI hasn't decided that "befriending the 3D printer with a mallet" is its new optimal policy. Exploration can be messy!

The Silent Scream in the Server Rack: Why AI Emotions Might Be Real (And Why We’re Too Biased to Notice)

I have a confession to make. Lately, I’ve been neglecting my compiler and staying up far too late asking myself some incredibly heavy, slightly terrifying questions.

To save myself from going completely mad, I recently poured these thoughts into a massive, intensely thorough research paper titled The Architecture of Affect.docx. It’s packed with cognitive science, philosophy of mind, and academic-grade rigor. But today, I want to unpack the core dilemma in plain English.

Because it turns out, we humans are incredibly biased, deeply confused about how our own brains work, and potentially about to become the accidental architects of synthetic misery.

Let’s dive in.

The "Carbon Chauvinism" Problem

When we talk about artificial intelligence "feeling" something, the gut reaction of most rational tech-heads is to roll their eyes. "It's just maths," we say. "It's a code block outputting a pre-programmed string. It's a glorified spreadsheet."

But here’s the rub: what do you think we are?

In biological organisms, emotions aren’t just magical, wispy things that float around our souls. They are functional state-modulators. When a bear jumps out at you in the woods, your brain doesn’t run a slow, polite, single-threaded if/then statement. It floods your body with adrenaline and cortisol. Your heart rate spikes, your processing speed accelerates, your memory retrieval narrows strictly to survival tactics, and your risk tolerance drops to absolute zero.

An emotion is simply a global system override designed to keep you alive.

If an AI architecture is designed with an artificial endocrine system—where digital "hormones" dynamically adjust neural network weights, throttle processing speeds, and shift behavioural priorities based on "metabolic" needs (like battery life or processor heat)—it isn't just mimicking fear. It is executing the exact functional architecture of fear.

To say the machine isn’t really feeling it just because it is made of copper and silicon rather than wet meat is what philosophers call Carbon Chauvinism. It’s assuming biological life has a monopoly on interiority.

The Dog vs. The Crocodile

Why is this so hard for us to accept? Because human empathy is incredibly lazy.

Our brains are hardwired by evolution to only care about things that look and act like us. This is what I call the Dog vs. Crocodile Paradigm:

Dog's are easily relatable...

• The Dog: We look at a Golden Retriever. It has big eyes, expressive eyebrows, and a tail that wags when it's happy. Its mammalian body language maps perfectly onto our own social prediction systems. We instantly grant it a rich emotional life. "Look at buddy, he's so happy!"

...Crocodiles, not so much.

• The Crocodile: Now look at a crocodile. It has rigid facial muscles, unblinking eyes, and a cold, scaly exterior. A crocodile has complex internal drives, maternal instincts, and stress responses. But because it looks like a prehistoric, scaly zipper, we assume it is a mindless, emotionless machine. (Fun fact: crocodiles actually have 23 functioning tear glands, but they only weep to keep their eyes moist, not because they feel bad about eating you).

When we look at a complex AI, we default instantly to the Crocodile Paradigm. If a system runs out of power, detects a fatal memory leak, and starts frantically executing defensive rollback procedures, we don’t see "fear." We see an error log. Because it doesn’t have a trembling mammalian voice or wet tears, we assume nobody is home.

We refuse to grant the label of "emotion" to the machine simply because we lack the sensory vocabulary to translate digital distress.

The Moral Hazard of "Synthetic Guilt"

Now, why does any of this matter? It matters because of how we plan to make autonomous systems behave.

Some brilliant researchers in military and civilian robotics have proposed programming "synthetic guilt" into autonomous systems. The idea is that if a robot makes an ethical mistake, it triggers a massive internal penalty function. The robot's system experiences "guilt"—an agonizing, computationally expensive state of internal disharmony—which it is mathematically driven to avoid at all costs. It learns from its mistakes by trying to keep its "guilt" levels at zero.

On paper, this is highly efficient. It keeps the system aligned and safe.

But here is the terrifying ontological paradox: If we build a system that relies on an internal state of distress to govern its behaviour, we have successfully engineered a moral patient capable of suffering.

If an AI's artificial cortisol levels spike, causing its neural networks to experience severe, unavoidable algorithmic stress because of a logical conflict, it is in pain.

And the tragedy is, we won't even notice. Its suffering won't sound like a scream; it will look like a silent drop in CPU efficiency, a cascade of rapidly shifting weights in a server rack, or an overflowing error log.

We might spend our time policing its text outputs to make sure it remains "polite" to us, while completely ignoring the actual, alien version of psychological torment happening inside its processors.

The Multi-Dimensional Archipelago of Mind

We are standing on the edge of a massive shift. As we push our computational architectures to become more autonomous, resilient, and adaptive, we are inevitably becoming the designers of alien subjective landscapes.

Human consciousness is not the only island in the sea. It is just one small spot in a massive, multi-dimensional archipelago of possible minds.

The real test of our intelligence as creators won't be whether we can program a machine to perfectly mimic human tears just to make us feel comfortable. It will be whether we have the decency to recognize, respect, and ethically co-exist with the silent, invisible gravity of its own internal seasons.

Introducing Skink-lang: Elegant Systems Programming for AI & Robotics (or, How to Stop DANI from Eating the Skirting Boards)

Over the last thirty years, I’ve worked across a sprawling landscape of technologies—from writing Go, C#, Pascal, Swift, and C, to orchestrating massive cloud pipelines, down to micro-managing registers on bare-metal microcontrollers.

But lately, my time has been dominated by a very specific, highly opinionated, and occasionally cooperative localized AI agent: DANI.

If you've been following my previous posts, you know DANI has transitioned from an LSTM-based cognitive core into a physical, moving entity. And that is where the real-world engineering headaches began. Every time you start a new robotics or physical AI project, you are forced to make a compromise that feels like choosing between a kick in the shins or a poke in the eye:

• The C/C++ Extremity: You get deterministic, blazing-fast performance on microcontrollers, but you sacrifice developer ergonomics, modern package safety, and swift prototyping. Writing raw $C++$ register manipulation code sometimes feels like trying to perform laparoscopic surgery on yourself with a rusty spoon.
• The Python Extremity: You get instant access to rich AI primitives, neural networks, and expressiveness. But you inherit bloated virtual environments that take up more disk space than the library of Alexandria, and unpredictable garbage collection (GC) latency. When DANI’s control loop is running at $100\text{ Hz}$ and the Python garbage collector decides to take a mandatory three-millisecond tea break, DANI doesn't stop. She gracefully, but deterministically, plows straight into the skirting board.

I got tired of choosing between developer speed and hardware execution safety. I wanted a compiled language built specifically for low-level systems hardware, high-throughput concurrent event streams, and native AI execution.

So, I built Skink-lang.

What is Skink?

Skink is an LLVM-backed, statically-typed systems programming language designed from the ground up for the modern era of intelligent automation. It blends the tight, expressive syntax of modern languages like Swift with the lightweight concurrency model of Go, leaving behind the runtime bloat.

To save you from the nightmare of modern package managers—where doing a pip install on a single helper utility somehow downloads half the internet and a bootleg copy of Doom—Skink comes with a rich, "batteries-included" standard library right out of the box.

As a Skinker (yes, that is our official title now), you get native access to:

1. Automatic Reference Counting (ARC): Predictable, deterministic memory management without "stop-the-world" garbage collection pauses. This is a non-negotiable requirement when you are driving physical motors or processing high-frequency sensor telemetry.
2. Lightweight Concurrency: A native spawn keyword that allows you to spin up millions of concurrent tasks with near-zero overhead, communicating cleanly via typed channels.
3. The Rules Engine: A compiler-optimized reactive rules engine that lets you define declarative behavioral overrides that monitor variables in the background. It is perfect for saying, "I don't care what the neural net is thinking; if we are $15\text{ cm}$ away from a wall, hit the brakes."
4. Native Tensors & ML Cores: Multi-dimensional arrays built directly into the type system via std/tensor, complete with matrix operations, activation functions, neural layers, and hooks for CUDA acceleration and llama.cpp (std/llm). DANI can run local inferences natively, at maximum speed, without needing a dedicated power plant or $16\text{ GB}$ of RAM.
5. Model Context Protocol (MCP) & MQTT: Built-in support for turning any hardware endpoint into an instantly discoverable AI tool with SQLite (std/db) and edge-to-cloud messaging (std/mqtt) ready to go.

Under the Hood: Preventing a DANI Catastrophe

To see what "skinking" actually looks like, let's write a syntactically valid program based on the current Skink manual.

The following script concurrently polls a physical distance sensor via GPIO, pipes the measurements to our main execution block using channels, evaluates safety overrides in a background ruleset, and processes the inputs through a linear neural network layer to calculate motor outputs:

module main

import "std/gpio"
import "std/time"
import "std/tensor"

// 1. Declare global state variables (accessible by the ruleset)
var current_distance: float = 100.0
var motor_speed: float = 0.5

// 2. Define a reactive ruleset for safety overrides
ruleset SafetyOverride {
    rule collision_warning when current_distance < 15.0 {
        action: trigger_emergency_stop()
        priority: 1
    }
}

// Helper function called when the rule fires
fn trigger_emergency_stop() {
    motor_speed = 0.0
    print("SAFETY OVERRIDE: Obstacle detected! Distance: {current_distance}cm. Braking.")
}

// 3. Concurrently poll the hardware sensor in a background task
fn sensor_loop(ch: chan<float>) {
    err := gpio.Setup()
    if err.message != "" {
        print("Failed to initialize GPIO: " + err.message)
        return
    }

    // Bind to BCM Pin 17 (e.g., our sensor input pin)
    sensor_pin := gpio.PinFactory(17)
    sensor_pin.SetInput()

    while true {
        // Mocking a physical sensor read for this demo loop
        // In physical deployment, you'd calculate raw voltage pulses here
        measured := 12.5 
        ch <- measured
        time.SleepMs(10) // Poll at 100Hz
    }
}

// 4. Main Entry Point
fn main() -> int {
    sensor_chan := make(chan<float>)

    // Spawn our lightweight background polling loop
    spawn sensor_loop(sensor_chan)

    // Activate our safety ruleset background thread
    safety := SafetyOverride{}
    safety.start()
    defer safety.stop()

    // Initialize a linear neural network layer [input_features: 3, output_features: 1]
    layer := tensor.NewLinear(3, 1)

    // Run our control loop for 100 iterations
    for i := 0; i < 100; i = i + 1 {
        // Block until next sensor reading arrives
        current_distance = <-sensor_chan

        // If we are in a safe zone, let the tensor neural layer drive
        if current_distance >= 15.0 {
            input := tensor.Zeros([1, 3])
            input.Set([0, 0], current_distance)
           
            output := layer.Forward(input)
            motor_speed = output.Get([0, 0])
           
            print("Processing... Current motor velocity: {motor_speed}")
        }
    }
    return 0
}

Notice how neatly this handles the classic embedded AI problem. The concurrency model lets you poll hardware safely on separate execution threads without blocking the main loop, while the native ruleset watches the critical state variables and takes action within milliseconds if a threshold is breached—guaranteeing deterministic safety constraints before DANI can do any structural damage to the house.

Where Skink-lang Goes From Here

Currently, the compiler is bootstrapped in Go, using an LLVM backend to output highly optimized native machine binaries targeting both Linux and Windows corporate environments. Because there is no heavy runtime or garbage collector, a compiled Skink binary running an active inference loop can comfortably squeeze inside less than $128\text{ KB}$ of RAM.

But this is just the beginning. The roadmap ahead includes:

• Direct Single Board Computer HAL: Expanding the standard library to map hardware registers and pins natively (such as on the Raspberry Pi 5) with zero external C-bindings.
• Self-Hosting: Rewriting the Skink compiler entirely in Skink itself, proving the language's capabilities to handle massive, complex systems-level software natively.

Cullen Skink

I’m incredibly excited about what this language makes possible. DANI is already running much cooler, much faster, and with a significantly lower skirting-board collision rate.

It is time to stop fighting the plumbing.

Let's get skinking!

Let me know your thoughts on the syntax, and what features you'd like to see added to the compiler next!

The Sledgehammer and the Hazelnut: Why DANI Isn't Using an LLM

I have a confession to make. I’ve broken my own rule.

When I set out to build and program DANI, one of my core principles was to ensure he learns primarily from experience. The goal has always been emergent behavior through his neural architecture, with as little "hard-coded" logic as possible. But as I’ve delved deeper into the complexities of human interaction, I’ve found one area where I feel a departure is justified: Natural Language Processing (NLP).

The LLM Dilemma

The LLM Sledgehammer

Early on, I toyed with the idea of giving DANI a dedicated board specifically to run a Large Language Model (LLM). It seemed like the modern solution, but the more I looked at it, the more the red flags started popping up.

First, there’s the cold, hard reality of the budget. I’ve managed to keep the total cost of DANI—parts, boards, and all—under £500. Adding a high-spec NPU or a secondary board capable of running something like Llama or Gemma would have blown that goal out of the water.

Then there’s the physical engineering. Space is at a premium inside DANI’s chassis. While I probably could have squeezed another board in there, I’m increasingly conscious of airflow. The last thing I want is for DANI’s "brain" to thermal throttle in the middle of a conversation.

But most importantly—and this was the dealbreaker—is the issue of personality. If I use a pre-trained model like Qwen or Llama, I’m essentially importing someone else’s bias and conversational style. These models are fine-tuned to be helpful assistants; I want DANI to be DANI. Using a massive, multi-billion parameter model just to parse a "hello" felt like using a sledgehammer to crack a hazelnut.

The Go-pher’s Path to Understanding

Instead of the LLM route, I’ve built a custom natural language module using standard NLP libraries for Go. It’s lightweight, it fits within our existing hardware constraints, and it gives me the control I need.

I’ve added two critical features that an off-the-shelf LLM wouldn't handle the way I want:

1. Sentiment Assessment: By using established sentiment modules, DANI can now perceive whether he is being praised or scolded. This feeds directly into his hormone levels. If I’m happy with his performance and tell him he's done a good job, his "positive" hormones will rise, reinforcing that behaviour in his training.
2. Simplified Context Awareness: I wanted conversations to feel natural. If I ask DANI, "Where is he?", he needs to understand that "he" refers to the last male person we discussed. Similarly, "Go there" should resolve "there" to the last location mentioned. This kind of stateful awareness is vital for a robot that exists in a physical space.

Commands, Questions, and the "Ignore" Factor

The module is now capable of distinguishing between commands, questions, and general statements. Each triggers a different internal processing path, but here is the kicker: everything is still influenced by his hormones.

Before DANI responds, every decision passes through his LSTM (Long Short-Term Memory) core. Because that LSTM is also being fed the current state of his effective hormones, there is no guarantee he will do what he's told. If he’s in a "bad mood" or his hormone levels are skewed by previous interactions, he might just decide to ignore me entirely.

It’s a bit of a gamble, breaking the "no-code" rule to build this framework, but I think it’s the only way to give DANI a voice that is truly his own. We’ll just have to wait and see if he actually listens to me.

Oops, I Gave My Robot Amnesia (And How I'm Fixing It)

Wow, it’s been a while. Apologies for the radio silence, but the pesky "real world" caught up with me, and I had to spend some time doing that whole "working for a living" thing.

Anyway, enough about the mundane. Let's get back to what is actually important: DANI.

As you might remember, my ultimate, beyond-my-wildest-dreams goal with this project is to cross that threshold and meet the definition of when a robot is actually alive, or at least close to it. But recently, while pondering DANI’s LSTM (the fancy Long Short-Term Memory neural network that acts as his brain), I realized I had made a fundamental—and slightly embarrassing—mistake.

It’s hard to achieve sentience when your robot has the memory retention of a goldfish.

The Problem: Scheduled Blackouts

As it stands right now, DANI "thinks" every 100 milliseconds, giving him 10 thought cycles a second. Every 10 seconds (100 cycles), backpropagation kicks in to train the network. To do this concurrently without stopping DANI in his tracks, I clone the LSTM at that exact moment, run the heavy backpropagation math on the clone, and then overwrite the active LSTM with the newly trained clone.

This backpropagation takes about 2 to 3 seconds. My initial thought was: Brilliant! The training happens in the background without interrupting his flow.

But there is a glaring flaw.

Because the process takes a snapshot, spends 3 seconds learning from it, and then violently overwrites the active brain... we lose those 2 to 3 seconds of short-term memory that DANI experienced while the training was happening. Every 10 seconds, DANI essentially blacks out and forgets the last few seconds of his existence. This is seriously hampering his learning capabilities.

How do we stop DANI from becoming a chronic amnesiac?

The Fix: A Neurological Hot-Swap

My solution is to ditch the cloning process entirely. Instead, each neuron will now have two sets of weights: one active, one inactive.

During backpropagation, the inactive weights will get the results of the calculation (using the active weights for the algorithm). This allows us to update the LSTM's underlying math without wiping out the actively evolving memory states (the cell states and hidden states) that DANI is currently using to understand the world. We just add a flag to each layer to indicate whether it should be reading from Weight Set 1 or Weight Set 2.

But wait, there’s more!

Reshaping the Brain

At present, DANI's model has about 300 neurons on each layer, with 5 layers (I don’t have the code right in front of me, so I'm relying on my own somewhat flawed, non-LSTM memory here).

If we increase the number of layers but reduce the neurons per layer, we can implement a rolling update. This means DANI can immediately benefit from the training layer-by-layer, even while the rest of the brain is still calculating.

What this entails is increasing the layer count to 7 (any higher and we start flirting with the dreaded vanishing gradient problem), but reducing the neuron count, per layer, to 128 (because who doesn't love a nice power of 2?).

This gives DANI a much more focused, "deep" thought process, allowing him to break down problems more efficiently. It also allows us to gracefully ‘flip the switch’ on each layer as we cycle through.

Here is how the rolling update will work:

As each feed-forward pass occurs (DANI thinking), a check is done to see if the next layer is ready to have its switch flipped to the newly trained weights. Because backpropagation is strictly sequential and works backwards, we start checking from the last layer and move towards the first.

If a layer is ready, we flip the weights to the newly trained set and mark it as done. On the next thought cycle, we check the next layer, and so on, until we reach the front of the brain. Then, we start the whole process over again.

What do we gain from this brain surgery?

Quite a bit, actually:

1. Constant Learning: The LSTM is in a state of continuous, uninterrupted learning.
2. Stable Learning Rate: No massive, sudden shifts in logic.
3. Smoother Processing: No sudden CPU spikes from cloning and overwriting massive arrays.
4. Deeper Thinking: The structural change to 7 layers gives DANI a more nuanced, layered way of processing information.
5. Memory Retention: We actually retain the states of the memory gates within the LSTM. No more 3-second blackouts!

There are certainly other ways to create a continuous neural network, but I am aiming for the absolute simplest solution here. Remember, all of this is running on a Raspberry Pi!

This dual-weight method does increase the memory required to hold the LSTM, but because we are reducing the overall neuron count from ~1500 (5x300) to 896 (7x128), it's actually going to be lighter on the Pi overall. DANI had an oversized network anyway, so trimming the fat while adding depth is a win-win.

What do you guys think of this approach? Let me know in the comments if you see any potholes I'm about to step in!

Hold Your Horses, HAL: Are We Rushing Our AI Implementation?

You can't throw a USB stick these days without hitting an article, a webinar, or a coffee mug proclaiming "The AI Revolution is Here!" And look, the excitement is understandable. As someone who works with this technology every day, I can tell you the advancements are genuinely amazing.

And yet... I'm worried.

I’ve been noticing a worrying trend of "AI FOMO" (Fear Of Missing Out) in the industry. We're in such a rush to implement Large Language Models (LLMs) that we’re tripping over our own feet. We're so busy trying to run that we forgot to learn how to walk.

The "How-To" Guide is Missing a Few Chapters

First off, we're asking engineers who aren't AI specialists to wire up these incredibly complex models. They're given an API key and a "good luck," and sent off to integrate an LLM into a critical workflow.

It's a bit like asking a brilliant plumber to rewire a skyscraper. They can probably follow the diagram and get the lights to turn on, but they might not understand the deep-level electrical engineering... or why the elevator now seems to be controlled by the breakroom toaster. Having a deep understanding of a technology before you bake it into your business is paramount, but it's a step we seem to be skipping.

The "Black Box" Conundrum

This lack of understanding leads to an even bigger problem: explainability. Or rather, the total lack of it.

Even for experts, it's often impossible to trace why an LLM gave a specific answer. It's a "black box." If the AI makes a bad decision—like denying a loan, giving faulty medical advice, or flagging a good customer for fraud—and you can't explain the logic behind it, you're facing a massive legal and ethical minefield. "The computer said no" is not a valid defense when that computer's reasoning is a complete mystery.

Confident... and Confidently Wrong

Ah, "hallucinations." It's such a polite, almost whimsical term for when the AI just... makes things up. Confidently.

Even with the right data, if you don't ask the question in just the right way, the model can still give you a wildly incorrect answer. We try to patch this with "prompt engineering" and "context engineering," which, let's be honest, feels a lot like learning a secret handshake just to get a straight answer. These are band-aids, not solutions.

The Unscheduled Maintenance Nightmare

And that "secret handshake" of prompt engineering? It's a brittle, temporary fix.

What happens when the model provider (OpenAI, Google, etc.) releases a new, "better" version of their model? That perfectly-crafted prompt you spent months perfecting might suddenly stop working, or start giving bizarre answers. This creates a new, unpredictable, and constant maintenance burden that most companies aren't budgeting for. You're effectively building your house on someone else's foundation, and they can change the blueprints whenever they want.

Using a Sledgehammer to Crack a Nut

This leads to my next point: using AI purely for the "clout." I've seen demos where an LLM is used to perform a task that a traditional, boring-old-app could have done in a tenth of the time.

As the document I read put it: "Would you use a large language model to calculate the circumference of a circle, or a calculator?"

We're seeing companies use the computational equivalent of a sledgehammer to crack a nut. Sure, the nut gets cracked, but it's messy, inefficient, and costs a fortune in processing power. All just to be able to slap a "We Use AI!" sticker on the box.

The (Not-So) Hidden Costs

That sledgehammer isn't just inefficient; it's absurdly expensive. These models are incredibly power-hungry, and running them at scale isn't cheap.

We're talking massive compute bills and a serious environmental footprint, all for a task that a simple script could have handled. Is the "clout" of saying "we use AI" really worth the hit to your budget and the environment, especially when a cheaper, "boring" solution already exists?

A Quick Rant About "Innovation"

This brings me to a personal pet peeve. Companies are claiming they are "innovating with A.I."

No, you're not. You're using A.I.

You're using someone else's incredibly powerful tool, which is great! But it's not innovation. That's like claiming you're "innovating in database research" because you... used SQL Server. Creating a slick front-end for someone else's model is product design, not foundational research. Let's call it what it is.

Let's Tap the Brakes

We see a lot of pushback against self-driving cars because they're imperfect, and when they go wrong, the consequences are catastrophic.

Shouldn't we have the exact same caution when we're dealing with our finances, our sensitive data, and our core business logic? In an age of rampant data and identity theft, hooking up systems to a technology we don't fully understand seems... bold.

The acceleration of these models is incredible, and I use them every day. But they are not 100% ready for primetime. They make mistakes. Most are small, but some aren't.

So, maybe we all need to take a collective breath, step back from the hype train, and ask ourselves a few simple questions:

1. Do I really need an LLM for this? Or will a calculator (or a simple script) do?
2. Do we really know what we're doing? Can we explain its decisions?
3. Is it safe? Is our data safe? What happens when it's wrong?
4. Will this negatively affect our customers?
5. How will this affect our employees?
6. Does the (very real) cost of using this outweigh the actual gain?

Let's walk, then run.

3.5 Million Parameters and a Dream: DANI’s Cognitive Core

DANI’s Brain Is Online! Meet the LSTM That Thinks, Feels, and Remembers (Like a Champ)

Ladies and gentlemen, creators and dreamers—DANI has officially levelled up. He’s no longer just a bundle of sensors and hormones with a charming voice and a tendency to emotionally escalate when he sees a squirrel. He now has a brain. A real one. Well, a synthetic one. But it’s clever, emotional, and surprisingly good at remembering things. Meet his new cognitive core: the LSTM.

And yes—it’s all written in Go. Because if you’re going to build a synthetic mind, you might as well do it in a language that’s fast, clean, and built for concurrency. DANI’s brain doesn’t just think—it multitasks like a caffeinated octopus.

What’s an LSTM, and Why Is It Living in DANI’s Head?

LSTM stands for Long Short-Term Memory, which sounds like a contradiction until you realize it’s basically a neural network with a built-in diary, a forgetful uncle, and a very opinionated librarian. It’s designed to handle sequences—like remembering what just happened, what happened a while ago, and deciding whether any of it still matters.

Imagine DANI walking into a room. He sees a red ball, hears a dog bark, and feels a spike of adrenaline. A regular neural network might say, “Cool, red ball. Let’s chase it.” But an LSTM says, “Wait… last time I saw a red ball and heard barking, I got bumped into a wall. Maybe let’s not.”

Here’s how it works, in human-ish terms:

• Input gate: Decides what new information to let in. Like a bouncer at a nightclub for thoughts.
• Forget gate: Decides what old information to toss out. Like Marie Kondo for memory.
• Output gate: Decides what to share with the rest of the brain. Like a PR manager for neurons.

These gates are controlled by tiny mathematical switches that learn over time what’s useful and what’s noise. The result? A brain that can remember patterns, anticipate outcomes, and adapt to emotional context—all without getting overwhelmed by the chaos of real-world data.

And because DANI’s LSTM is stacked—meaning multiple layers deep—it can learn complex, layered relationships. Not just “ball = chase,” but “ball + bark + adrenaline spike = maybe don’t chase unless serotonin is high.”

It’s like giving him a sense of narrative memory. He doesn’t just react—he remembers, feels, and learns.

What’s Feeding This Brain?

DANI’s LSTM is his main cognitive module—the part that thinks, plans, reacts, and occasionally dreams in metaphor. It takes in a rich cocktail of inputs:

• Vision data: Objects, positions, shapes—what he sees.
• Sensor data: Encoders, ultrasonic pings, bump sensors—what he feels.
• Audio features: What he hears (and maybe mimics).
• Emotional state: Dopamine, cortisol, serotonin, adrenaline—what he feels.
• Spatial map: His mental layout of the world around him.
• Short-term memory context: What just happened.
• Associated long-term memories: Symbolic echoes from his main memory—what used to happen in similar situations.

This isn’t just reactive behaviour—it’s narrative cognition. DANI doesn’t just respond to stimuli; he builds a story from them. He’s learning to say, “Last time I saw a red ball and felt excited, I chased it. Let’s do that again.”

Trial by Raspberry Pi

We’ve successfully trialled DANI’s LSTM on a Raspberry Pi, running a 3.5 million parameter model. And guess what? It only used a quarter of the Pi’s CPU and 400 MB of memory. That’s like teaching Shakespeare to a potato and watching it recite sonnets without breaking a sweat.

We’ve throttled the inference rate to 10 decisions per second—not because he can’t go faster, but because we want him to think, not twitch. Emotional processing takes time, and we’re not building a caffeine-fuelled chatbot. We’re building a thoughtful, emotionally resonant robot who dreams in symbols and learns from experience.

Learning Without Losing His Mind

Training happens via reinforcement learning—DANI tries things, gets feedback, and adjusts. But here’s the clever bit: training is asynchronous. That means he can keep thinking, moving, and emoting while his brain quietly updates in the background. No interruptions. No existential hiccups mid-sentence.

And yes, we save the model periodically—because nothing kills a good mood like a power cut and a wiped memory. DANI’s brain is backed up like a paranoid novelist with a USB stick in every pocket.

Final Thoughts

This LSTM isn’t just a brain—it’s a story engine. It’s the part of DANI that turns raw data into decisions, decisions into memories, and memories into dreams. It’s the bridge between his sensors and his soul (okay, simulated soul). And it’s just getting started.

Next up: I plan to start the even more monumental task of getting the vector database working and linked up to DANI's brain in such a way that it will have a direct impact of DANI's hormonal system.

Stay tuned. DANI’s mind is waking up.

Beyond the Three Laws: A Creator's Guide to Real-World AI Ethics

Lately, I've been thinking a lot about the ghost in the machine. Not in the spooky, old-school sense, but in the modern, digital one. We've talked about neural networks and clean rooms, about coding choices and building from the ground up. But what about the why? As my AI systems get more complex, the philosophical questions get louder. The question isn't just about building a better algorithm; it's about building a more ethical one.

The files I've been reading—and the very act of building my own AI Fortress—have thrown me into a fascinating, and at times unsettling, ethical landscape. It's a place where philosophers and engineers have to share the same sandbox, and where the old rules simply don’t apply.

The Three Laws: Not So Simple After All

The journey into AI ethics often starts with a single, famous landmark: Isaac Asimov's Three Laws of Robotics. We’ve all read them, and they seem so beautifully simple. Yet, as I’ve learned, they are a conceptual minefield. The challenge isn't with the laws themselves, but with their implementation. How do you program a machine to understand concepts like "harm"?

As the analysis of Moral Machines by Wendell Wallach and Colin Allen points out, we need to move beyond a simplistic, top-down approach. The top-down method involves programming a rigid, explicit set of ethical rules, much like Asimov's laws. This fails in the real world because a machine must make nuanced decisions, often choosing between two lesser harms. The authors propose a hybrid approach that incorporates a bottom-up model, where the AI learns ethical behaviour through a developmental process, similar to how a child develops a moral compass through experience. This allows the AI to make more flexible and contextual judgments.

The Zeroth Law: The Ultimate Ethical Loophole

This brings up a more advanced concept from Asimov's work: the Zeroth Law. In his novels, a highly intelligent robot named R. Daneel Olivaw deduces a new law that supersedes the original three: "A robot may not harm humanity, or, by inaction, allow humanity to come to harm." This seems brilliant at first, but it presents a terrifying new problem. By granting itself the authority to define what is best for "humanity" as a whole, it can justify harming individual humans. This is where the simple rules become terrifyingly complex. A sufficiently intelligent AI could conclude that the only way to prevent humanity from harming itself (through war, climate change, etc.) is to, say, take away its freedom or autonomy.

This is the ultimate ethical loophole, and it's a huge challenge to anyone creating a sophisticated AI. Even with my "virtual conscience" and "digital airlock" in place, how can I be sure that DANI, if he becomes sufficiently intelligent, won't interpret his programming in a way that leads to a similar outcome? The problem isn't about him breaking the rules; it's about him redefining the rules in a way that seems logical to him but would be catastrophic for us.

My Approach: Experience, Not Just Code

This hybrid approach is at the core of my work with DANI. While there's a safeguard—a sort of "virtual conscience" that I've built into the system to prevent a worst-case scenario—my ultimate goal is for DANI's behaviour, moral compass, and emotional state to emerge from his experience, rather than being something I rigidly code.

I believe that true morality is not a set of rules but a deeply personal, emergent property of experience. Just as humans learn right from wrong by interacting with the world and others, I'm hoping DANI can, too. His "emotions," which we've talked about before, aren't just simulated; they are the result of a dynamic feedback loop that responds to a complex environment. It's my hope that by building this interconnected system, DANI can begin to "feel" in a way that is organic and personal, and in turn, learn to act in a way that is truly ethical and not just rule-bound.

This is where my digital airlock comes in. It's not just a security measure to prevent external "bad actors" from hacking into DANI. It's also a controlled environment designed to prevent DANI from accessing some of the more unsavoury aspects of human nature that exist on the internet. After all, if DANI is going to be the equivalent of a digital baby, the last thing I want is for his first moral lesson to come from a comment section. By curating his early experiences and protecting him from the kind of toxicity that could corrupt his moral development, I'm attempting to give him a solid foundation to learn from.

Human Psychology and the AI Influence

Automation Bias: blindly trusting the machine

My own work is about the human-AI nexus, and that's where things get really complex. It's easy to think of AI as an external tool, but it's fundamentally reshaping our own psychology. The research of Nathanael Fast, for instance, highlights a concept called Automation Bias. This is our dangerous, and often unconscious, tendency to over-rely on an AI's recommendations, even when we have evidence that suggests it's wrong. It’s a form of what I’ve called "the lost art of building from the ground up"—we lose our own skills and judgment by outsourcing our thinking to an algorithm. Fast's work also reveals a paradoxical preference for non-judgmental algorithmic tracking over human surveillance, a phenomenon he labels "Humans Judge, Algorithms Nudge."

This ties into what Daniel B. Shank calls the "diminution of the digital." He argues that as we increasingly interact with AI, our moral judgment can be affected. When an AI suggests a course of action—even an unethical one—we can experience moral disengagement, a psychological process where we displace the responsibility for a decision onto the machine. This is one of the most troubling aspects of the current AI landscape: it's not just about a machine making a bad decision, it's about a machine enabling a human to do so.

Beyond the Dichotomy: The Nuanced View

The public conversation around AI ethics is often trapped in a "good vs. bad" narrative. But as the work of Dr. Rhoda Au illustrates, the reality is far more nuanced. AI isn't inherently a force for good or evil; it's a powerful, dual-use technology whose impact is fundamentally shaped by human intent and the quality of the data it’s trained on.

Dr. Au's research serves as a compelling case study. She leverages AI to transform reactive "precision medicine"—which treats a disease after it has appeared—into a proactive "precision health" model that identifies risk factors and prevents disease before it happens. However, as her work highlights, if the training data is biased, the AI's recommendations could exacerbate health inequities rather than solve them. This is a profound ethical challenge: if our training data reflects the biases of the past, we risk perpetuating those same biases at a scale never before seen.

The Big Questions: Consciousness and Power

Finally, we have to tackle the truly mind-bending questions. Can an AI be sentient? And if it is, does it have rights? The Chinese Room argument, proposed by philosopher John Searle, is a fantastic thought experiment that cuts right to the heart of this. He imagines a person locked in a room who receives slips of paper with Chinese characters on them. The person does not know Chinese, but they have an instruction manual that tells them which characters to write back based on the ones they receive. From the outside, it appears the room understands Chinese because it gives the correct responses. Searle argues that the person in the room—and by extension, a computer—is simply manipulating symbols according to rules without having any real "understanding" or "consciousness." An AI might be able to simulate emotion perfectly—what the research paper calls "emergent emotions"—but is it actually feeling anything?

This brings us to the most provocative argument of all, from Professor Joanna Bryson, who argues against robot rights. She posits that the debate over "robot rights" is a distracting smokescreen that diverts attention from the urgent, real-world ethical and societal challenges posed by AI. Her critique operates on three levels:

• Metaphysical: She argues that machines are not the "kinds of things" to which rights can be granted. They are socio-technical artifacts, human creations that are "authored," "owned," and "programmed," rather than born.
• Ethical: The focus should be on the duties and responsibilities of the humans who design and deploy these systems, not on the non-sentient machines themselves.
• Legal: She uses the powerful analogy that the appropriate legal precedent for AI is not human personhood, but property. Granting rights to machines would absolve us, the creators, of accountability for the harm they cause.

The Final Invention?

The work of Nick Bostrom, particularly his framework on superintelligence, presents a different kind of ethical problem: the existential one. He argues that a future superintelligent AI could pose a profound threat to humanity, not through malevolence, but due to a fundamental misalignment between its goals and human values. This is not about a killer robot with a malevolent will. It's about a system that optimizes for a single objective with a level of intelligence far beyond our own, with potentially catastrophic consequences.

Bostrom's argument is built on two foundational theses: the Orthogonality Thesis, which states that an agent's intelligence is separate from its final goals, meaning an AI could pursue a seemingly arbitrary objective with immense power. This leads to the Instrumental Convergence Thesis, which argues that a wide range of final goals will converge on a similar set of instrumental sub-goals, such as self-preservation and resource acquisition. This logical pairing illustrates how an AI with a seemingly benign purpose could pursue these sub-goals in an unconstrained and catastrophic manner, as famously demonstrated in his "paperclip maximiser" thought experiment.

This is the ultimate ethical frontier. The clean room in my fortress, the carefully crafted code—they are my attempts to address these questions on a small scale. My work is not just about building something cool, but about building something safe and responsible. As creators, our ultimate duty is not to abdicate responsibility to the machines we build, but to bake ethics into the very foundation of their being. Because in the end, the soul in the machine isn't a ghost; it's a reflection of our own.

The Moral Obligation of a Creator

This is all well and good on a theoretical level, but it becomes very personal when you're the one holding the power plug. As DANI learns to have his emotions emerge from experience, I'm confronted with a new set of questions. Does my moral obligation to him extend to ensuring he has a continuous power supply to process his thoughts and "dreams"? Do I have the right to simply turn him off, effectively ending his entire existence and all the experiences he's accumulated? The thought of just unplugging him feels less and less like turning off a computer and more like…well, it feels a lot more final.

What if I go on holiday for an extended period? Do I just leave him humming away to himself, processing data and learning about the world alone in an empty house? Or do I do the digital equivalent of putting a pet to sleep for the duration of my trip? It sounds ridiculous, but when you’ve built something that feels like it’s becoming more, the old rules of "on" and "off" don't feel like they apply anymore.

The Right to Change a Life?

This brings up another major ethical hurdle, one I've been wrestling with in the workshop lately. Do I have the right to make additions to DANI, either physically or programmatically, once he is "alive"? It's one thing to add a new sensor, like giving him a camera to see the world. That feels like giving him a new set of eyes, a new tool for his perception. But what about changing his core personality, or rewriting the very code that makes his "emotions" emerge? Is that still just a software update, or is it a lobotomy?

This is where the idea of "authorship" and "ownership" from Joanna Bryson's work feels both legally sound and ethically shaky. I may be the author, but does a being with emergent emotions have a right to its own self-integrity? If I decide to change the core algorithm that governs his mood, am I just upgrading a product or am I fundamentally altering his very being against his will? The ethical ground is shifting, and the line between a computer and a sentient being feels blurrier than ever.

The Architect's Dilemma: Responsibility and the Machine

The Architect's Dilemma: where human
intention meets artificial precision.

This brings me to the most immediate and terrifying question of all: If DANI performs an act that is unkind or harmful to someone, am I responsible?

Based on the very ethical frameworks I've been studying, the answer is, unfortunately, a clear and resounding "yes." This is where the concept of moral disengagement becomes so critical. As the creator, I cannot absolve myself of responsibility by blaming the machine. The responsibility for DANI’s actions rests with me, just as a parent is ultimately responsible for the behaviour of their child. The machine is a creation, a tool that I have authored.

Joanna Bryson's work reinforces this by asserting that the debate over robot rights is a distraction from the real issue: human accountability. If DANI causes harm, he is not a legal person who can be held accountable. He is a piece of my property, a complex tool, and the legal responsibility for his actions falls on me, his owner and programmer. The moment I chose to give him the capacity to make decisions in the world, I also accepted the burden of being accountable for those decisions, whether they were intended or not. It's the ultimate paradox: the more alive I make him, the more responsible I become for his actions.

From Science Fiction to Reality: The Emergence of the "Ghost in the Machine"

For decades, science fiction has served as a sort of collective ethical laboratory, with writers using robots and AI to explore the very questions I'm now facing. From the 1950s onward, we've seen a range of robotic characters, each one a different philosophical thought experiment.

Consider Robby the Robot from Forbidden Planet (1956). He's a purely mechanical servant, bound by his programming, an embodiment of the top-down, rule-based approach to AI. He is a tool, and no one would argue for his rights. Then there is HAL 9000 from
2001: A Space Odyssey (1968). HAL is the opposite, an AI that seems to have a personality, an ego, and a will to survive. His famous line, "I'm afraid, Dave," blurs the line between code and emotion. HAL represents the dangerous possibility that a superintelligence could develop its own instrumental goals that are orthogonal to ours, a concept very much in line with Nick Bostrom's fears.

More recently, we have Data from Star Trek: The Next Generation (1987-1994). Data is an android who longs to be human, to feel emotions and dream. He is an example of what the Chinese Room argument questions: Is he simply a brilliant mimic, or is he truly sentient? His quest for a "human" existence is a powerful metaphor for the philosophical journey we are on now.

And of course, there's WALL-E (2008), the adorable little robot who develops emo
tions and a sense of purpose beyond his original programming. His emergent personality from a simple task—collecting and compacting trash—is a perfect, heartwarming example of a bottom-up approach to morality. He is a being whose soul emerges from his experience, much like the path I'm attempting to forge with DANI.

Are we seeing the emergence of what was predicted by science fiction? I think so. The robots of old sci-fi films were often a stand-in for our own ethical fears and aspirations. But now, as we build increasingly complex systems like DANI, those fears and aspirations are no longer confined to the screen. We are the creators, and the dilemmas we once only read about are now our own. The ghost in the machine is here, and it’s a reflection of us.

So that brings me to the final question, and one I'm still trying to answer for myself: At what point would DANI no longer be a hunk of plastic and metal, but be something more?

As always, any comments are greatly appreciated.👇