Scott Pollard — Design, Code & Art

Category: Development

WordPress, PHP, HTML, CSS, JavaScript and development workflows.

  • AI is spoiling the enjoyment of surprise

    AI is spoiling the enjoyment of surprise

    We seem to have become obsessed with how quickly things can be done. How quickly can we build the website? How quickly can we create the concept? How quickly can we write the code? And increasingly, how quickly can AI do all of the above?

    Speed has become one of the easiest ways to measure progress. If something took two days and now takes two hours, that must be better. And in plenty of situations, it absolutely is. But I’m starting to wonder whether we’ve accidentally started optimising something else out of the process.

    Surprise.

    We don’t like uncertainty very much

    Most businesses are naturally built around reducing uncertainty. We create processes, make templates, automate repetitive tasks, establish best practices and look at what worked last time so we can do more of it. It makes perfect sense.

    If a problem can be solved logistically rather than creatively, logistics normally wins. Creativity introduces uncertainty. You might spend three hours exploring an idea only to discover it doesn’t work. You might write some code, run it and get an error. You might design something, leave it overnight, come back the following morning and decide it’s rubbish.

    From a productivity point of view, this isn’t particularly efficient. But perhaps that inefficiency has some value.

    I’ve probably had this thought reinforced by watching many Rory Sutherland lectures. One of the recurring ideas I’ve taken from his work is that we’re very good at valuing things we can logically explain and measure. Efficiency is easy to defend in a meeting. Spending an afternoon experimenting with something that might go nowhere is rather harder.

    Ludwig von Mises wrote about something he called the “joy of labour”. Part of that joy comes from mastering something and being able to look at the result and think: I know how to make this. There’s another part I think anyone who has spent time coding will recognise. That feeling when something finally works.

    Not because somebody handed you the answer, but because you’ve spent an hour changing things, reading documentation, breaking it, fixing it, breaking something else and eventually understanding what was wrong. The result matters, but so does everything that happened before the result.

    I’ve been thinking about this quite a lot while using AI for coding. There’s a particular little dopamine hit that comes from writing some code, hitting run and seeing something happen that you weren’t completely expecting. Sometimes it works. Sometimes it spectacularly doesn’t. Occasionally the mistake is actually more interesting than the thing you were trying to make.

    That happens in design too. Move something accidentally, try the wrong colour, crop an image strangely, misunderstand an instruction or combine two ideas that weren’t originally supposed to go together. You stop and think, actually, there’s something in that.

    Those moments are difficult to put on a project plan. They’re also some of the most interesting moments in creative work.

    Then along came “the full script please”

    I should probably admit something here. I use AI a lot.

    Over the past year I’ve used it to help me build all sorts of creative coding experiments. Generative artwork, simulations, data visualisations and interactive pieces. I’ll have an idea, describe it to ChatGPT, get some code, run it and then start experimenting.

    Make the pixels move. Add some randomness. Change the colours. What happens if gravity is added? Can we make it 3D?

    And, quite regularly:

    “The full script please.”

    (If ChatGPT starts saying replace that with this somewhere)

    It’s brilliant. An idea that might once have remained scribbled in a notebook can be running on my screen twenty minutes later. AI has opened up a creative playground for me. I can explore ideas quickly, make dozens of variations and pick out the strange, unexpected and beautiful things that appear along the way.

    I wouldn’t want to give that up.

    But there is a contradiction in there. The quicker I ask AI to solve every problem, the less time I spend understanding the problem myself. Eventually something subtle changes. I’m no longer making the thing in quite the same way. I’m directing the making of the thing.

    Those aren’t necessarily the same experience.

    Creativity needs some friction

    Steve Jobs once described creativity as connecting things. His argument was that creative people often arrive at interesting ideas because they’ve accumulated experiences and thought about them enough to make connections between them.

    I think there’s something important in that. You need some dots before you can connect them, and those dots often come from doing things the slow way. Reading the documentation. Trying something that doesn’t work. Learning why it doesn’t work. Remembering a completely unrelated technique from five years ago.

    It’s about understanding enough CSS, JavaScript, PHP or whatever else you’re using to know when the obvious solution isn’t necessarily the right one. AI can jump straight to a plausible answer, but sometimes the wandering around before the answer was where we acquired the knowledge that would help us solve the next problem.

    There’s another problem with efficiency too. It encourages us to stay where things are predictable.

    Businesses understandably like repeatable outcomes. Designers develop styles. Developers use familiar frameworks. Marketing teams repeat campaigns that performed well previously. Then AI arrives with an extraordinary ability to look at everything that already exists and give us another plausible version of it.

    That can make the safe lane even safer.

    The danger isn’t necessarily that AI produces bad work. Quite the opposite. It can produce perfectly competent work incredibly quickly, and perhaps that’s the more interesting problem. If the competent answer arrives almost instantly, what makes us continue exploring?

    Why try the strange idea? Why spend an afternoon making something that might not work? Why write the awkward first version yourself?

    Efficiency tells us to stop when the problem has been solved. Creativity often asks what happens if we keep going.

    Perhaps we need slow AI

    Perhaps we don’t actually need less AI. Perhaps we need slower AI.

    I don’t mean artificially making the computer take thirty seconds to answer instead of three. That would just be annoying. I mean slowing down how we use it.

    There is already some interesting research around this idea. Researchers have explored “Reflective AI”, applying ideas from slow technology to creative education. Rather than treating AI purely as a machine for producing finished outputs, the idea is to use it in ways that encourage reflection, understanding and engagement with the process.

    I like that distinction because it changes the relationship we have with the tool.

    Imagine asking AI not to give you the finished function, but to explain what might be causing the problem. Ask for three possible approaches. Ask it to explain the part you don’t understand. Write your own version, break it and then ask AI why it broke.

    The goal changes from get me to the answer as quickly as possible to help me explore this.

    AI becomes less like a vending machine and more like someone sitting next to you while you work.

    I don’t want to give the speed back

    None of this means I want to return to development before AI. I don’t.

    AI has removed huge amounts of tedious work from my day. It helps me investigate unfamiliar code, generate starting points, debug problems and explore ideas that would otherwise require far more time than I have available.

    My everyday development work now sits somewhere between AI-assisted and traditionally written code. Sometimes I know exactly what I want and writing it myself is quicker. Sometimes AI gets me 80% of the way there. Sometimes I deliberately work through the problem because I want to understand it.

    And sometimes I just want the full script please.

    The important thing, I think, is recognising that these choices have different consequences. Saving time is useful. Learning is useful. Enjoyment is useful too.

    We’ve spent decades making computers faster. Then we made the internet faster, our workflows faster and our development tools faster. Now AI can compress hours of thinking and making into minutes. That’s an extraordinary achievement.

    But perhaps speed shouldn’t be the only measurement.

    There is value in knowing how something works. There is value in struggling with something for a while. There is value in making the wrong thing. And there is definitely value in pressing run without being entirely sure what is going to happen.

    Because sometimes the best part isn’t that it worked.

    It’s the surprise when it does.

    Acknowledgement

    A quick shout out to Rory Sutherland, whose lectures and talks I’ve really enjoyed watching online. His way of questioning our obsession with logic, efficiency and optimisation has definitely influenced some of the thinking behind this article.

    These aren’t necessarily Rory’s conclusions about AI. They’re my own thoughts, but his work certainly helped send me down this particular rabbit hole.

    References and further reading

    Ludwig von Mises, Human Action: A Treatise on Economics
    In his discussion of the “joy and tedium of labour”, Mises considers the satisfaction that can accompany work, including the pride of being able to look at something and say, essentially, “I know how to make this. This is my work.”

    Steve Jobs, interviewed by Gary Wolf, WIRED, 1996
    Jobs discusses design as something requiring genuine understanding rather than simply appearance. In the same interview he describes creativity as connecting experiences and argues that broader experiences give people more “dots” to connect.

    Rory Sutherland
    Vice Chairman of Ogilvy UK, author of Alchemy: The Surprising Power of Ideas That Don’t Make Sense, and a frequent speaker on behavioural economics, creativity and the limitations of purely rational decision-making. His talks and lectures around efficiency, logic and human behaviour were an influence on the thinking behind this article.

    Reflective AI and slow technology
    Research presented at CHI 2026 explores “Reflective AI”, looking at how deliberately slowing AI-supported creative processes can encourage reflection, understanding and creative agency rather than simply optimising for faster outputs.

  • Kaleidoscopes: cool, but still not very usable

    Kaleidoscopes: cool, but still not very usable

    I remember kaleidoscopes mostly from museum gift shops.

    Not necessarily the expensive museums either. Science museums, little local museums, National Trust gift shops — anywhere that had a rack of slightly educational toys alongside pencils, gemstones and things that glowed in the dark.

    I always thought kaleidoscopes were brilliant.

    You’d point one towards a window, slowly turn the end and suddenly something completely ordinary was transformed into this incredibly complicated geometric pattern. Turn it a few millimetres more and it was gone forever, replaced by something else.

    There was something particularly good about the fact that you weren’t really creating the image. You were just finding it.

    Sometimes retro stays retro

    The problem is that kaleidoscope graphics have never really escaped the kaleidoscope.

    There are plenty of old visual ideas that disappear for a while and then find a completely new context. Others seem permanently attached to the era or culture that popularised them.

    Tie-dye is perhaps a good example. You can reinvent it, change the colours, put it on an expensive T-shirt and photograph it beautifully — but somewhere underneath, it’s still tie-dye.

    Kaleidoscope graphics feel similar.

    They’re psychedelic. They’re a bit 1960s. They’re album artwork. They’re screen savers. They’re those music visualisers we used to leave running on computers.

    They’re cool, but still not very usable.

    And that’s partly what made me want to make one.

    Building my own kaleidoscope

    Rather than trying to make a single piece of artwork, I started building a kaleidoscope image generator in Processing.

    You load an ordinary photograph and the software starts pulling it apart through rotation, repetition and reflection.

    The first versions behaved much more like a traditional kaleidoscope. The image is divided into radial segments and those segments are repeated around a central point.

    Six sides.

    Eight.

    Ten.

    Twelve.

    Fourteen.

    Sixteen.

    Then mirrored versions. Flipped versions. Mirrored and flipped versions.

    And because it’s code rather than a physical object, the rules don’t have to stop there.

    The photograph can slowly rotate inside the segments while the overall structure rotates independently. Alternate sections can travel clockwise and anticlockwise. They can flip as they move.

    Suddenly the source photograph becomes almost irrelevant.

    You’re looking at relationships between tiny bits of it instead.

    Finding things in reflections

    This is where the experiment became more interesting to me.

    There are some genuinely interesting shapes and forms to be found in reflection.

    A small line in a photograph might become a six-pointed structure. A bit of shadow can turn into an architectural form. Something completely insignificant near the edge of the original image can become the dominant feature of the generated one.

    It feels a little like looking for faces in clouds.

    You’re not necessarily designing the shape directly. You’re creating the conditions that allow you to discover it.

    That also meant I became less interested in recreating a real kaleidoscope and more interested in abusing the underlying idea.

    Breaking the kaleidoscope

    The project now contains 34 different filters.

    Some remain fairly traditional: Hex Core, Octa Mirror, Dec Flip Mirror and Dodec Core.

    Others start pulling the principle apart.

    Spiral Mirror twists the repeated sections as they move away from the centre.

    Alternating Rings breaks the image into concentric sections travelling in opposing directions.

    Liquid Kaleido deliberately distorts the geometry so the reflections ripple and bend.

    Crystal Shards treats the photograph more like a sheet of fractured reflective material.

    Orbit Cells puts fragments of the image into individual circular lenses moving around the composition.

    Then there are experiments such as Infinity, Infinity Tunnel and Helix Tunnel, where the original two-dimensional kaleidoscope idea starts moving into three-dimensional space.

    At that point I’m not entirely sure they qualify as kaleidoscopes any more.

    Which is probably a good thing.

    The photograph becomes raw material

    One thing I’ve particularly enjoyed is seeing how differently photographs behave once they’re fed into the system.

    A photograph doesn’t need to be particularly good.

    In fact, an unremarkable photograph can sometimes produce a better result because you’re no longer really interested in its original composition.

    Colour, texture, edges, highlights and shadows become the raw materials.

    A tiny patch of yellow might suddenly repeat around the centre and create a flower-like form. Straight architectural lines become impossible structures. Organic textures can produce things that look strangely biological.

    And because everything is moving, you can simply pause when something interesting appears.

    P pauses the animation.

    S renders the current composition as a high-resolution PNG.

    So the software is less about producing the final kaleidoscope and more about continuously presenting possibilities.

    But would I actually use one?

    That’s the question I’ve kept coming back to.

    Probably not.

    At least, I don’t think I’m about to start putting giant kaleidoscope graphics into website headers or designing psychedelic posters.

    But I don’t think that makes the experiment pointless.

    The interesting bit might not be the finished kaleidoscope at all.

    It might be one tiny crop from it.

    A strange piece of reflected typography. An unexpected symmetrical mark. A texture. A shape that could become the beginning of something completely unrelated.

    That’s where generative tools become particularly useful to me. They don’t necessarily have to make the finished piece of design.

    Sometimes they just need to show you something you wouldn’t have thought to draw.

    And perhaps that’s ultimately what I liked about those little museum kaleidoscopes in the first place.

    You weren’t really looking through them to see the world.

    You were turning them until you found something interesting.

  • Ten Heartbeats and an Eclipse

    Ten Heartbeats and an Eclipse

    There’s something quite nice about watching a solar eclipse through a Pringles tube.

    For all the technology we have around us, our preparations for the eclipse involved raiding the recycling and making pinhole viewers from cereal boxes and Pringles tubes. Very similar, really, to the sort of thing I remember doing at school in the 90s.

    We’d planned a fairly secluded spot to watch it from, only to discover that a few other people had apparently had exactly the same idea.

    That actually made the evening better.

    We met some like-minded people, compared our slightly questionable homemade viewing contraptions and then stood around together waiting for the Moon to move across the Sun.

    It got me thinking afterwards about the experience of an eclipse beyond simply seeing it.

    What if you could see how people reacted?

    The eclipse is obviously a huge visual event, but there’s another part of it that you can’t see.

    Anticipation.

    Excitement.

    The strange change in light.

    Waiting for the right moment.

    And, potentially, the physiological response to all of that.

    That led to another little generative art experiment.

    What if ten people watching an eclipse recorded their heart rates, and those heartbeats became the eclipse’s corona?

    Rather than creating a conventional graph showing beats per minute over time, I wanted the data to become part of the artwork itself.

    Ten people. Ten heart rates. One Eclipse.

    The piece is being developed in Processing.

    At the centre is a simple representation of the eclipse: a black disc surrounded by a thin, warm edge of light.

    Behind it are ten separate circular systems.

    Each person gets their own complete 360-degree layer made from hundreds of fine radial lines. Every layer has its own colour, pattern and heart rate, but they’re all positioned around exactly the same point.

    So you don’t immediately see ten separate data visualisations.

    You see one.

    The layers overlap, interfere with each other and occasionally align, creating something resembling a colourful solar corona.

    The important difference is that the corona is being generated by people.

    Turning a heartbeat into movement

    I didn’t want the heart-rate data to simply control the height of the lines.

    That felt too much like an audio equaliser.

    Instead, each heartbeat creates an event.

    The radial lines slowly push away from the eclipse, reach their maximum extension and then ease back towards it.

    I’ve deliberately exaggerated and slowed this movement. A literal visual representation of a heartbeat becomes incredibly frantic when ten people are running simultaneously.

    The data determines when something happens, but the artwork determines how that event feels.

    So each beat becomes more of a swell:

    rest → expansion → peak → decay

    At the peak of a pulse, fragments also begin to escape from the ends of the lines.

    These become tiny particles travelling away from the centre before slowly disappearing.

    I like the idea that the lines represent the immediate physical response, while the particles leave behind a temporary memory of what has already happened.

    Stacked, not divided

    One decision that became important quite early was how to represent the ten participants.

    The obvious solution would be to divide the circle into ten sections, giving everyone a 36-degree slice.

    But that would turn the artwork into a diagram.

    Instead, all ten people occupy the entire circle.

    Their layers are stacked.

    Person one can pulse across all 360 degrees. So can person two, person three and everyone else.

    Their heartbeats are also staggered, so the layers continually move in and out of phase with one another.

    Every so often several beats might happen at almost the same moment and create a much larger burst.

    Those moments aren’t specifically animated or programmed.

    They’re coincidences in the data.

    And that’s probably one of my favourite parts of the idea.

    Compressing an eclipse into sixty seconds

    I don’t want the final piece to run for the actual duration of the eclipse.

    Instead, the recorded heart-rate data would be compressed into roughly one minute.

    The beginning of the observation becomes the beginning of the animation. Maximum eclipse sits somewhere within that timeline, followed by the gradual return towards normality.

    That gives the finished piece its own beginning, middle and end.

    It also raises an interesting question.

    Will anything actually happen at maximum eclipse?

    It would be very easy to artificially make that moment enormous — more particles, longer lines, brighter colours.

    But that would defeat the point.

    If everyone’s heart rate increases as the eclipse approaches maximum, the artwork should naturally become more energetic.

    If everyone’s heart rate remains relatively unchanged, then that’s what the artwork should show.

    The interesting bit is finding out.

    Building an instrument rather than a fixed animation

    While developing it, I’ve also added a control panel to the Processing sketch.

    I can adjust the pulse duration, strength, radial density, line thickness, particle speed, particle lifetime, eclipse size, glow, layer spacing and overall playback speed while the artwork is running.

    This has become quite important.

    There isn’t really a calculation that tells me a heartbeat should produce a line exactly 126 pixels long or that a particle should survive for precisely 140 frames.

    Those are visual decisions.

    The data provides the structure, but there’s still a process of designing how that data is interpreted.

    Being able to move a slider and watch all ten systems respond immediately makes the Processing sketch feel less like a finished animation and more like an instrument for exploring the idea.

    From a Pringles tube to Processing

    That’s probably what I like most about this little project.

    It started with something incredibly analogue.

    A cardboard tube. A cereal box. A tiny hole. Sunlight projected onto a piece of card.

    The same basic method of observing an eclipse that I remember from being younger.

    Then there we were, years later, standing outside with our homemade viewers and a few people we’d only just met, all looking at the same event.

    Now I’m taking that experience back to the computer and asking what else could have been recorded.

    Not just what did the eclipse look like?

    But:

    What did it feel like to be there?

    And could ten tiny streams of biological data turn that feeling into something we can see?

    That’s what I want to find out next.

  • Study 02: Addition

    Study 02: Addition

    For the second experiment in this series, I wanted to keep the rules almost identical to the first project and change just one thing.

    Study 01 used multiplication to determine the rotation of each line. This time, I’ve replaced the lines with outlined squares and changed the mathematics from multiplication to addition.

    The question became:

    What if every square knew where it was?

    Each square sits within a regular grid. Its position is described by two values: its column and its row. Instead of multiplying those values together, I simply add them.

    float angle = radians(column + row);

    Every square is then rotated by the angle produced from that calculation.

    The result is surprisingly different. Squares that share the same column + row value also share the same rotation, creating gentle diagonal bands that flow across the composition. Where the multiplication project felt more complex and unpredictable, this one feels calmer and much more structured.

    Nothing else changes.

    • The grid remains fixed.
    • Every square is the same size.
    • Every outline has the same weight.
    • Only the mathematical relationship has changed.

    This is what fascinates me about working in code. A tiny adjustment to a single formula can completely alter the visual language of the piece.

    Like the first project, this isn’t about creating a finished artwork. It’s about asking a simple question, changing one variable, and observing what happens.

    Sometimes the smallest mathematical change produces the biggest visual surprise.