Reflections on computer-generated code...

... and assessing it

Nov 20, 2025

Is a computer-generated story as good as a human-created one? In this post I refer to Italo Calvino and Jonathan Swift, and then generate a couple of versions of an original story of mine using a bespoke computer program.

Greetings!

One of the things I’ve been trying out is reworking a piece of text into a completely different style. A full exposition and explanation are given here:

Eclecticism: Reflections on literature and life

Experimenting with styles

Introduction A good way of improving your writing skills is to try reworking texts into a completely different style or genre. To some extent this overlaps with parody writing, which I intend to explore in a separate post, but as a quick example, consider this. In Brand X Fiction, a collection of parodies of fiction writers…

3 years ago · 2 likes · 6 comments · Terry Freedman

For today’s experiment I’ve produced two versions of the story using a computer program based on my original.

First, though, here is the original text on which these experiments or transformations are based:

The original (template) text

In the middle of the night, I woke up (if you can call being semi-conscious being awake), walked purposefully towards the door to go to the bathroom — and almost knocked myself out.

The reason was that in the twin states of entire darkness and semi-somnambulance I was facing in a different direction from the one I thought I was facing. As a result, instead of walking through the door, I tried to walk through the wall.

The next few days brought nausea and headaches. After much prevarication I went to Accident and Emergency, where I waited petrified among people for whom “social distancing” means not quite touching you, and who wore their masks as a chin-warmer.

An hour and a half later I emerged into the twilight, secure in the knowledge that I had nothing more serious than mild concussion. I failed to do much writing, but I was pleased to have read a further 17% of my book.

The program code version

The writer Italo Calvino believed that a computer could create stories:

Once you think of a story merely as an assemblage of discreet elements, combined according to logical rules existing outside the author, [Calvino] realised, then literature becomes like mathematics. And this means that, in theory, ‘electronic brain’ – that is, computers – should be able to write literature just as well as human beings. Indeed, given that they can sort through possible combinations much more efficiently than us, they might be even better. So why would there be any need for authors in the future?

From Calvino and the machines1.

Jonathan Swift, much earlier, had a similar idea. Jonathan Swift’s description of a writing machine occurs in Gulliver’s Travels, Book III, Chapter 5, where he details an elaborate device called “The Engine” at the Academy of Projectors in Lagado. This fictional contraption is essentially designed to automate the production of books by mechanically combining words into sentences. Here is a key portion of Swift’s description:

The first professor I saw, was in a very large room, with forty pupils about him. After salutation, observing me to look earnestly upon a frame, which took up the greatest part of both the length and breadth of the room, he said, “Perhaps I might wonder to see him employed in a project for improving speculative knowledge, by practical and mechanical operations…”
He then led me to the frame, about the sides, whereof all his pupils stood in ranks. It was twenty feet square, placed in the middle of the room. The superfices was composed of several bits of wood, about the bigness of a die, but some larger than others. They were all linked together by slender wires….
These bits of wood were covered, on every square, with paper pasted on them; and on these papers were written all the words of their language, in their several moods, tenses, and declensions; but without any order. The professor then desired me “to observe; for he was going to set his engine at work.”
The pupils, at his command, took each of them hold of an iron handle, whereof there were forty fixed round the edges of the frame; and giving them a sudden turn, the whole disposition of the words was entirely changed. He then commanded six-and-thirty of the lads, to read the several lines softly, as they appeared upon the frame; and where they found three or four words together that might make part of a sentence, they dictated to the four remaining boys, who were scribes….
This work was repeated three or four times, and at every turn, the engine was so contrived, that the words shifted into new places, as the square bits of wood moved upside down….

Here is a video to illustrate it, created using Google Flow.

Swift’s invention was designed so that, through random permutations and brute labour, even the “most ignorant person” could produce volumes of philosophy, poetry, politics, and more, “without the least assistance from genius or study.” The satirical intent is to mock the mechanization of learning, but Swift’s description anticipates both combinatorial writing techniques and concepts found in later computational creativity.

For this experiment I instructed an AI app2 to create pseudo code that would result in my original story, or one like it, being generated. The code it produced was this:

Initialize scene_options = [‘In the middle of the night’, ‘Just before dawn’, ‘During an afternoon nap’]
Initialize wake_state_options = [‘semi-conscious’, ‘barely awake’, ‘groggy’, ‘in a dreamlike haze’]
Initialize destinations = [‘the door’, ‘the bathroom’, ‘the kitchen’]
Initialize obstacles = [‘the wall’, ‘a cupboard’, ‘the window’]
Initialize symptoms_options = [‘nausea’, ‘headaches’, ‘dizziness’, ‘blurred vision’]
Initialize excuses = [‘prevarication’, ‘reluctance’, ‘hesitation’]
Initialize places = [‘Accident and Emergency’, ‘the local hospital’, ‘the urgent care centre’]
Initialize crowd_behaviours = [‘not quite touching’, ‘standing far too close’, ‘ignoring personal space’]
Initialize mask_behaviours = [‘worn as a chin-warmer’, ‘pulled below the nose’, ‘lying in a pocket’]
Initialize waiting_times = [’an hour and a half’, ‘forty minutes’, ‘two hours’]
Initialize discharge_states = [’secure in the knowledge’, ‘relieved’, ‘disappointed’]
Initialize diagnosis_options = [’mild concussion’, ‘no major damage’, ‘just a bump’]
Initialize failure_actions = [‘failed to do much writing’, ‘couldn’t manage any drawing’, ‘barely touched my emails’]
Initialize progress_actions = [‘pleased to have read’, ‘glad to have finished’, ‘happily got through’]
Initialize book_progress = [‘a further 17%’, ‘three chapters’, ‘half the book’]

RANDOMLY select scene, wake_state, destination, obstacle, symptom, excuse, place, crowd_behaviour, mask_behaviour, waiting_time, discharge_state, diagnosis, failure_action, progress_action, book_progress

Narrative Construction:
output = scene + ‘, I woke up (if you can call being ‘ + wake_state + ‘ being awake), walked purposefully towards ‘ + destination + ‘ — and almost knocked myself out.’
output += ‘The reason was that in the twin states of entire darkness and ‘ + wake_state + ‘ I was facing in a different direction from the one I thought I was facing. As a result, instead of walking through ‘ + destination + ‘, I tried to walk through ‘ + obstacle + ‘.’
output += ‘The next few days brought ‘ + symptom + ‘. After much ‘ + excuse + ‘ I went to ‘ + place + ‘, where I waited petrified among people for whom “social distancing” means ‘ + crowd_behaviour + ‘, and who wore their masks as ‘ + mask_behaviour + ‘.’
output += ‘After ‘ + waiting_time + ‘ I emerged into the twilight, ‘ + discharge_state + ‘ that I had nothing more serious than ‘ + diagnosis + ‘. I ‘ + failure_action + ‘, but I was ‘ + progress_action + ‘ ‘ + book_progress + ‘ of my book.’

Print output

I then asked the AI to use the program it had created to generate a new version of the story. Here’s what it produced:

Just before dawn, I woke up (if you can call being groggy being awake), walked purposefully towards the kitchen — and almost knocked myself out.
The reason was that in the twin states of entire darkness and grogginess I was facing in a different direction from the one I thought I was facing. As a result, instead of walking through the kitchen doorway, I tried to walk through a cupboard.
The next few days brought dizziness and blurred vision. After much reluctance I went to the local hospital, where I waited petrified among people for whom “social distancing” means standing far too close, and who wore their masks pulled below the nose.
After two hours I emerged into the twilight, relieved that I had nothing more serious than just a bump. I couldn’t manage any drawing, but I was glad to have finished three chapters of my book.

Well, I don’t know about you, but my opinion of that is the same as Dr Johnson’s views on women preaching:

“Sir, a woman’s preaching is like a dog’s walking on his hind legs. It is not done well; but you are surprised to find it done at all.”

So, in desperation, I asked the AI to “write” a new version of the story, using the same elements but making it less boring. Here is the result:

Just before dawn, my semi-conscious brain decided that the kitchen was calling. Shadows danced on the hallway walls as I marched with heroic intent towards what I thought was the fridge. Instead, my forehead met the sharp edge of a cupboard with a thud that echoed in the silence — my personal fanfare for disaster.
Staggering back, my senses swirled in darkness and confusion. I fumbled for a light switch, but reality was laughing in the corner: I’d aimed for the tea but launched a surprise assault on kitchen furniture.
The days that followed were a fever dream of dizziness, blurred vision, and inexplicable cravings for toast. Eventually, after performing the ancient rite of putting off all responsibility, I dragged myself to the local hospital, feeling less like a patient and more like an undercover detective in a room of suspects. Everyone was locked in silent warfare over personal space; a wiry fellow glared at me while cozying his mask just under his chin, as if keeping his cheeks warm were NHS policy.
Two hours of boredom, paranoia, and overheard arguments about biscuits came and went. At last, a nurse waved me over. Good news: only a minor bump and a major lesson in midnight navigation. The aftermath? Drawing was impossible — every pencil seemed to move on its own. But I devoured three chapters of my book, mind alive with images of anti-gravity beds and sentient cupboards.

Good grief! It seems to have gone mad. Part of it sounds like I suddenly became pregnant:

“The days that followed were a fever dream of … inexplicable cravings for toast.

Mind you, I liked this:

“…a wiry fellow glared at me while cozying his mask just under his chin, as if keeping his cheeks warm were NHS policy.”

I think that is quite humorous, especially as it could well be NHS policy given that nobody in the hospital seemed to be enforcing the rules.

I’m not sure at which point I became an artist rather than a writer. And as for dreaming of antigravity beds, all I can say to AI is: don’t give up the day job.

I also asked the AI to generate code for a user-input version:

BEGIN PROGRAM

DISPLAY “Welcome to the Random Story Generator!”
DISPLAY “You can choose some details or let the program decide randomly.”

# Step 1: Define lists of possible options
scene_options = [‘In the middle of the night’, ‘Just before dawn’, ‘During an afternoon nap’]
wake_state_options = [‘semi-conscious’, ‘barely awake’, ‘groggy’, ‘in a dreamlike haze’]
destinations = [‘the door’, ‘the bathroom’, ‘the kitchen’]
obstacles = [‘the wall’, ‘a cupboard’, ‘the window’]
symptoms_options = [‘nausea’, ‘headaches’, ‘dizziness’, ‘blurred vision’]
excuses = [‘prevarication’, ‘reluctance’, ‘hesitation’]
places = [‘Accident and Emergency’, ‘the local hospital’, ‘the urgent care centre’]
crowd_behaviours = [‘not quite touching’, ‘standing far too close’, ‘ignoring personal space’]
mask_behaviours = [‘worn as a chin-warmer’, ‘pulled below the nose’, ‘lying in a pocket’]
waiting_times = [‘an hour and a half’, ‘forty minutes’, ‘two hours’]
discharge_states = [‘secure in the knowledge’, ‘relieved’, ‘disappointed’]
diagnosis_options = [‘mild concussion’, ‘no major damage’, ‘just a bump’]
failure_actions = [‘failed to do much writing’, ‘couldn’t manage any drawing’, ‘barely touched my emails’]
progress_actions = [‘pleased to have read’, ‘glad to have finished’, ‘happily got through’]
book_progress = [‘a further 17%’, ‘three chapters’, ‘half the book’]

# Step 2: Ask for user input or random choice
PROMPT “Do you want to choose the time of day? (yes/no)”
IF user_input == “yes”
    DISPLAY scene_options
    PROMPT “Enter your choice:”
    scene = user_choice
ELSE
    scene = RANDOM(scene_options)

PROMPT “Would you like to set your wakefulness description? (yes/no)”
IF user_input == “yes”
    DISPLAY wake_state_options
    PROMPT “Enter your choice:”
    wake_state = user_choice
ELSE
    wake_state = RANDOM(wake_state_options)

PROMPT “Choose your destination or pick random? (enter name or ‘random’)”
IF input == “random”
    destination = RANDOM(destinations)
ELSE
    destination = user_input

PROMPT “Do you want to specify the obstacle you walked into? (yes/no)”
IF user_input == “yes”
    DISPLAY obstacles
    PROMPT “Enter your choice:”
    obstacle = user_choice
ELSE
    obstacle = RANDOM(obstacles)

# Repeat similar logic for symptoms, place, waiting time, etc., giving option for custom or random.

symptom = ASK_OR_RANDOM(symptoms_options, “Would you like to choose your post-incident symptom?”)
excuse = ASK_OR_RANDOM(excuses, “Would you like to choose your reason for delay?”)
place = ASK_OR_RANDOM(places, “Would you like to choose the medical place?”)
crowd_behaviour = ASK_OR_RANDOM(crowd_behaviours, “Choose crowd behaviour?”)
mask_behaviour = ASK_OR_RANDOM(mask_behaviours, “Choose mask behaviour?”)
waiting_time = ASK_OR_RANDOM(waiting_times, “Choose waiting time?”)
discharge_state = ASK_OR_RANDOM(discharge_states, “Choose your emotional state after?”)
diagnosis = ASK_OR_RANDOM(diagnosis_options, “Choose your diagnosis?”)
failure_action = ASK_OR_RANDOM(failure_actions, “Choose what you failed to do?”)
progress_action = ASK_OR_RANDOM(progress_actions, “Choose reading progress action?”)
book_prog = ASK_OR_RANDOM(book_progress, “Choose amount read?”)

# Step 3: Construct the narrative
output = scene + “, I woke up (if you can call being “ + wake_state + “ being awake), “ +
“walked purposefully towards “ + destination + “ — and almost knocked myself out.” + NEWLINE

output += “The reason was that in the twin states of entire darkness and “ + wake_state +
“ I was facing in a different direction from the one I thought I was facing. “ +
“As a result, instead of walking through “ + destination + “, I tried to walk through “ + obstacle + “.” + NEWLINE

output += “The next few days brought “ + symptom + “. After much “ + excuse +
“ I went to “ + place + “, where I waited petrified among people for whom “social distancing” means “ +
crowd_behaviour + “, and who wore their masks as “ + mask_behaviour + “.” + NEWLINE

output += “After “ + waiting_time + “ I emerged into the twilight, “ + discharge_state +
“ that I had nothing more serious than “ + diagnosis + “. I “ + failure_action +
“, but I was “ + progress_action + “ “ + book_prog + “ of my book.”

# Step 4: Display result
DISPLAY NEWLINE + “Here is your randomised (and partly personalised) story:”
DISPLAY output

END PROGRAM

For each of these versions the AI also generated the code for Visual Basic and also Python. I haven’t tested these, but here are the two for the user-input version:

Python

import random

def ask_or_random(options, question):
    print(question)
    choice = input(”Enter your choice or press Enter for a random option: “).strip()
    if choice:
        return choice
    else:
        return random.choice(options)

def random_story():
    print(”Welcome to the Random Story Generator!”)
    print(”You can type your own choices or press Enter to let the program choose randomly.\n”)

    # Possible choices
    scene_options = [”In the middle of the night”, “Just before dawn”, “During an afternoon nap”]
    wake_state_options = [”semi-conscious”, “barely awake”, “groggy”, “in a dreamlike haze”]
    destinations = [”the door”, “the bathroom”, “the kitchen”]
    obstacles = [”the wall”, “a cupboard”, “the window”]
    symptoms_options = [”nausea”, “headaches”, “dizziness”, “blurred vision”]
    excuses = [”prevarication”, “reluctance”, “hesitation”]
    places = [”Accident and Emergency”, “the local hospital”, “the urgent care centre”]
    crowd_behaviours = [”not quite touching”, “standing far too close”, “ignoring personal space”]
    mask_behaviours = [”worn as a chin-warmer”, “pulled below the nose”, “lying in a pocket”]
    waiting_times = [”an hour and a half”, “forty minutes”, “two hours”]
    discharge_states = [”secure in the knowledge”, “relieved”, “disappointed”]
    diagnosis_options = [”mild concussion”, “no major damage”, “just a bump”]
    failure_actions = [”failed to do much writing”, “couldn’t manage any drawing”, “barely touched my emails”]
    progress_actions = [”pleased to have read”, “glad to have finished”, “happily got through”]
    book_progress = [”a further 17%”, “three chapters”, “half the book”]

    # Collect user input or random values
    scene = ask_or_random(scene_options, “Choose the time of day:”)
    wake_state = ask_or_random(wake_state_options, “Describe your state of wakefulness:”)
    destination = ask_or_random(destinations, “Where were you walking towards?”)
    obstacle = ask_or_random(obstacles, “What did you walk into?”)
    symptom = ask_or_random(symptoms_options, “Which symptom followed the incident?”)
    excuse = ask_or_random(excuses, “What reason delayed your hospital visit?”)
    place = ask_or_random(places, “Where did you go for treatment?”)
    crowd_behaviour = ask_or_random(crowd_behaviours, “Describe how the crowd behaved:”)
    mask_behaviour = ask_or_random(mask_behaviours, “Describe how people wore their masks:”)
    waiting_time = ask_or_random(waiting_times, “How long did you wait?”)
    discharge_state = ask_or_random(discharge_states, “How did you feel afterwards?”)
    diagnosis = ask_or_random(diagnosis_options, “What was the diagnosis?”)
    failure_action = ask_or_random(failure_actions, “What did you fail to accomplish afterwards?”)
    progress_action = ask_or_random(progress_actions, “What reading progress action suits you?”)
    book_prog = ask_or_random(book_progress, “How much of your book did you finish?”)

    # Compose story
    story = (
        f”{scene}, I woke up (if you can call being {wake_state} being awake), “
        f”walked purposefully towards {destination} — and almost knocked myself out.\n”
        f”The reason was that in the twin states of entire darkness and {wake_state} “
        f”I was facing in a different direction from the one I thought I was facing. “
        f”As a result, instead of walking through {destination}, I tried to walk through {obstacle}.\n”
        f”The next few days brought {symptom}. After much {excuse} I went to {place}, “
        f”where I waited petrified among people for whom “social distancing” means {crowd_behaviour}, “
        f”and who wore their masks as {mask_behaviour}.\n”
        f”After {waiting_time} I emerged into the twilight, {discharge_state} that I had nothing more serious “
        f”than {diagnosis}. I {failure_action}, but I was {progress_action} {book_prog} of my book.”
    )

    print(”\nHere’s your story:\n”)
    print(story)

random_story()

Visual Basic

Imports System

Module RandomStoryGenerator

    Function AskOrRandom(options As String(), question As String, rnd As Random) As String
        Console.WriteLine(question)
        Console.Write(”Enter your choice or press Enter for a random option: “)
        Dim input As String = Console.ReadLine().Trim()
        If input <> “” Then
            Return input
        Else
            Return options(rnd.Next(options.Length))
        End If
    End Function

    Sub Main()
        Dim rnd As New Random()
        Console.WriteLine(”Welcome to the Random Story Generator!”)
        Console.WriteLine(”You can type your own choices or press Enter to let the program choose randomly.”)
        Console.WriteLine()

        Dim scene_options() As String = {”In the middle of the night”, “Just before dawn”, “During an afternoon nap”}
        Dim wake_state_options() As String = {”semi-conscious”, “barely awake”, “groggy”, “in a dreamlike haze”}
        Dim destinations() As String = {”the door”, “the bathroom”, “the kitchen”}
        Dim obstacles() As String = {”the wall”, “a cupboard”, “the window”}
        Dim symptoms_options() As String = {”nausea”, “headaches”, “dizziness”, “blurred vision”}
        Dim excuses() As String = {”prevarication”, “reluctance”, “hesitation”}
        Dim places() As String = {”Accident and Emergency”, “the local hospital”, “the urgent care centre”}
        Dim crowd_behaviours() As String = {”not quite touching”, “standing far too close”, “ignoring personal space”}
        Dim mask_behaviours() As String = {”worn as a chin-warmer”, “pulled below the nose”, “lying in a pocket”}
        Dim waiting_times() As String = {”an hour and a half”, “forty minutes”, “two hours”}
        Dim discharge_states() As String = {”secure in the knowledge”, “relieved”, “disappointed”}
        Dim diagnosis_options() As String = {”mild concussion”, “no major damage”, “just a bump”}
        Dim failure_actions() As String = {”failed to do much writing”, “couldn’t manage any drawing”, “barely touched my emails”}
        Dim progress_actions() As String = {”pleased to have read”, “glad to have finished”, “happily got through”}
        Dim book_progress() As String = {”a further 17%”, “three chapters”, “half the book”}

        Dim scene = AskOrRandom(scene_options, “Choose the time of day:”, rnd)
        Dim wake_state = AskOrRandom(wake_state_options, “Describe your state of wakefulness:”, rnd)
        Dim destination = AskOrRandom(destinations, “Where were you walking towards?”, rnd)
        Dim obstacle = AskOrRandom(obstacles, “What did you walk into?”, rnd)
        Dim symptom = AskOrRandom(symptoms_options, “Which symptom followed the incident?”, rnd)
        Dim excuse = AskOrRandom(excuses, “What reason delayed your hospital visit?”, rnd)
        Dim place = AskOrRandom(places, “Where did you go for treatment?”, rnd)
        Dim crowd_behaviour = AskOrRandom(crowd_behaviours, “Describe how the crowd behaved:”, rnd)
        Dim mask_behaviour = AskOrRandom(mask_behaviours, “Describe how people wore their masks:”, rnd)
        Dim waiting_time = AskOrRandom(waiting_times, “How long did you wait?”, rnd)
        Dim discharge_state = AskOrRandom(discharge_states, “How did you feel afterwards?”, rnd)
        Dim diagnosis = AskOrRandom(diagnosis_options, “What was the diagnosis?”, rnd)
        Dim failure_action = AskOrRandom(failure_actions, “What did you fail to accomplish afterwards?”, rnd)
        Dim progress_action = AskOrRandom(progress_actions, “What reading progress action suits you?”, rnd)
        Dim book_prog = AskOrRandom(book_progress, “How much of your book did you finish?”, rnd)

        Dim story As String = $”{scene}, I woke up (if you can call being {wake_state} being awake), “ &
                              $”walked purposefully towards {destination} — and almost knocked myself out.{vbCrLf}” &
                              $”The reason was that in the twin states of entire darkness and {wake_state} I was facing “ &
                              $”in a different direction from the one I thought I was facing. As a result, instead of walking through “ &
                              $”{destination}, I tried to walk through {obstacle}.{vbCrLf}” &
                              $”The next few days brought {symptom}. After much {excuse} I went to {place}, where I waited petrified “ &
                              $”among people for whom “social distancing” means {crowd_behaviour}, and who wore their masks as {mask_behaviour}.{vbCrLf}” &
                              $”After {waiting_time} I emerged into the twilight, {discharge_state} that I had nothing more serious than {diagnosis}. “ &
                              $”I {failure_action}, but I was {progress_action} {book_prog} of my book.”

        Console.WriteLine()
        Console.WriteLine(”Here’s your story:”)
        Console.WriteLine()
        Console.WriteLine(story)
    End Sub

End Module

Assessment

Obviously, setting a homework like “Create a program that will do X” is not good enough in the age of AI. So I wanted to come up with some assessment questions that couldn’t be answered by AI. Here’s what the AI came up with:


write some assessment questions for that code which cannot be answered using AI

Certainly! Crafting assessment questions for programming code that **cannot be answered by AI** is a challenging task, as most code-related questions can at least be partially addressed by modern models. However, here are **assessment strategies** that focus on personal experience, practical debugging, physical classroom context, originality, creativity, and reflective learning—areas where AI cannot provide “correct” or fully authentic answers:

***

### Assessment Questions for the Random Story Generator Code

#### Practical Coding Experience
1. **Describe in detail a specific bug you encountered when testing the story generator, how you diagnosed it, and the precise steps you took to fix it. Include any code snippets you changed.**

2. **After running the story generator, what was the most unexpected or amusing output you personally encountered? Explain why it surprised or amused you.**

3. **What did you learn from running the program on your computer that you wouldn’t have realized by only reading the code?**

#### Reflective and Creative Tasks
4. **Modify the random story generator to reflect your own personality or experiences. Document the changes with before-and-after code snippets and explain your reasoning for each change.**

5. **Detail the steps you took to test your code for edge cases, and summarize the results you observed. Did you make any further changes based on this testing?**

6. **Describe any difficulties you had understanding the flow of user input within the code, and how you resolved them during implementation.**

#### Originality and Human Context
7. **Submit a hand-drawn or digitally illustrated depiction of your favourite “scene” generated by the program, and explain why you chose it.**

8. **Interview a classmate about their experience running the generator. Summarize what you learned from their perspective and how it differs from your own.**

9. **Describe how you would explain this project, and your code modifications, to a friend or family member who has never programmed before. What analogies or metaphors worked best?**

#### Code Customisation and Ethics
10. **Add a feature to the existing program that makes it more accessible for people with disabilities (e.g., screen reader compatibility, input validation). Describe the feature, and reflect on why accessibility matters in software design.**

***

**Note:** These questions require responses rooted in **personal experience, physical testing, and human creativity or interaction**, making them impossible or inappropriate for an AI to answer authentically or completely.

Then I asked it to draw up questions specifically related to the parts of Bloom’s Taxonomy:

Here is a list of assessment questions for the random story generator code, addressing each cognitive level of Bloom’s Taxonomy:

***

### Remembering
- List the main variables used in the random story generator code.
- Define what the function of the `random.choice()` (or equivalent) is in this program.

### Understanding
- Explain in your own words how the program creates different story outputs each time it runs.
- Describe how user input is incorporated into the program’s flow.

### Applying
- Show how you would modify the program to add an additional location to the “places” list.
- Demonstrate how the program handles a user pressing Enter without typing a choice.

### Analyzing
- Compare the difference in program flow when the user provides input versus when the program picks random options.
- Identify potential bugs or pitfalls that might occur if a user enters unexpected input (e.g., empty strings, invalid options).

### Evaluating
- Assess the strengths and weaknesses of the program’s design for user interaction.
- Critique the randomization approach used: does it produce meaningful or coherent stories? Why or why not?

### Creating
- Design and implement a new feature that allows the user to save their generated story to a file.
- Propose an extension to the program that would include multiple story arcs or branching choices based on prior inputs.

***

These questions comprehensively assess knowledge, comprehension, application, analysis, evaluation, and creativity related to the code and its functionality within Bloom’s framework.

I didn’t think these were wonderful because AI could be used to answer many of them. So I became a bit more precise in my prompt, by adding the caveat that the questions should not be able to be answered by AI:

Here is a list of assessment questions for the random story generator code, designed to specifically address each level of Bloom’s Taxonomy **and** crafted so they cannot be simply answered by AI (they require personal experience, reflection, practical work, or creativity):

***

### Remembering (Recall facts personally encountered)
- What specific variables and data structures did you define when implementing the story generator? List and describe them from memory without referring to your code notes.

### Understanding (Explain and interpret personally)
- In your own words, describe how user inputs and random selections combine to create a unique story. Provide examples from your own runs of the program.

### Applying (Show practical use and personal modification)
- Modify the program on your computer to include at least two new story elements or categories. Document your code changes and explain why you chose these additions.

### Analyzing (Break down and differentiate by hands-on experience)
- Review two versions of stories you generated—one fully random, one with user input—and compare how the structure and tone differ. Which do you think is more engaging, and why?

### Evaluating (Make judgments based on personal testing)
- Critique the usability of the program’s user input system based on your own testing. Suggest improvements grounded in your experience and briefly justify each recommendation.

### Creating (Produce original work with reflection)
- Design and implement a new interactive feature for the story generator based on feedback or your own ideas. Submit your modified code along with a short explanation of the feature’s purpose and how it enhances the user experience.

***

Each question asks for outputs, explanations, or reflections based on your personal programming and testing experience—something an AI cannot provide authentically because it does not: run code, experience bugs, make personal choices, or reflect on human usability.[1][2][3]

[1](https://dev.to/mttaggart/programming-and-blooms-taxonomy-85g)
[2](https://tophat.com/blog/blooms-taxonomy-question-stems/)
[3](https://whatfix.com/blog/blooms-taxonomy/)
[4](https://teaching.pitt.edu/resources/designing-discussion-questions-using-blooms-taxonomy-examples/)
[5](https://uwaterloo.ca/centre-for-teaching-excellence/resources/teaching-tips/blooms-taxonomy-learning-activities-and-assessments)
[6](https://blog.flocabulary.com/blooms-taxonomy-examples-for-educators/)
[7](http://www.landmarkoutreach.org/wp-content/uploads/blooms_revised.pdf)

I think on balance I prefer the very first set of suggestions. In another context, I asked AI to evaluate some student writing on a writing course I teach3, because I thought it might be interesting, and perhaps even save me some time! It suggested angles I hadn’t thought of, so in that sense was useful. However, it seemed to have a thing about the word “acrid”, making suggestions like, “Perhaps the writer could have talked about the acrid smells of the city” — that was for a piece of writing in which the focus was “show don’t tell”, so such explicit descriptions would be completely out of place.

My concusion from these sorts of experiments are as follows:

Setting assignments that could be answered by AI is pointless, unless the students use ther output as a launching point for their own analysis. For example, when I was teaching, if I wanted the students to enahnce some program code I gave them the code to begin with. I saw no value in asking them to type out the code in the first place.

It was the same when I wanted them to analyse data in a spreadsheet. I gave them the spreadsheet. When I was an Ofsted4 inspector the teacher in one lesson I visited had the students enter the data themselves. Some students took the whole lesson to enter just some of the data. In my opinion, it was all a complete waste of time. I asked the teacher afterwards why he’d done that, and he said it was because it would improve their keyboarding skills. My response was that a subject called keyboarding skills was not on the National Curriculum.

Using AI can be a good way of getting suggestions, but you will still need to build on them in order to achieve what you hope for.

Despite the caveats, though, there is no doubt that, used properly, AI can be a great time-saver.

Digital Education Newsletter

Discussion about this post

Ready for more?