### Part 1: Constrained Creative Writing (Horror)

The fluorescent lights in the open‑plan office hummed at a pitch that had never been there before. Three people sat at their desks in the far corner row: the intern, the project manager, and the office volunteer who came in on Wednesdays. None of them spoke. The only sound was the low click of keys, the dry wheeze of the heater, and the faint squeak of the intern’s chair whenever she leaned back.

The intern’s screen flickered, the same line of code repeating in different colors, each time one letter rearranged. The project manager watched his own monitor, where the same email had been open for ninety‑three minutes, though time‑stamped five days earlier. The volunteer’s hands hovered over the keyboard she had not used in three years, eyes fixed on a blank document titled “Exit Plan.”

The coffee machine in the breakroom gurgled, then stopped, then gurgled again in the exact same rhythm. The air grew thicker, the rows of desks beginning to look subtly identical, as if the same three people had been copied and pasted down the length of the floor. The intern’s coffee cooled, the manager’s inbox filled with messages that had never arrived, and the volunteer’s hands never moved.

No one spoke. No one left. The lights stayed on.

***

### Part 2: Constrained Creative Writing (Comedy)

The funeral was… quiet. The kind of quiet that makes you worry your own heartbeat is too loud. Two people sat near the front: Helen, who believed in structure, protocols, and proper seating charts, and Terry, who had arrived ten minutes late, still chewing gum, convinced the service had started at three.

“You realize we’re in the wrong room,” Helen whispered, eyes wide, as the organist played what sounded suspiciously like “I Will Survive” on a very solemn setting.

Terry swallowed the gum with a slight wince. “No we’re not. The card said ‘Room C, 11 a.m., crying optional.’ This is Room C.”

“But the coffin is empty,” Helen hissed. “And the program says ‘Celebration of Life’ for a person we’ve never met.”

Terry glanced at the name on the plaque: Robert Hargrave. “Maybe he’s a surprise guest? These ‘open‑mic’ funerals are trendy.”

The officiant stepped up, beaming. “Welcome, everyone, to the celebration of life for Robert Hargrave—and also our annual organizational meeting for the Harrogate Community Ghost‑Writing Service.”

Helen’s eyes darted to the opening line on the card in her hand: “Room C, 11 a.m., crying optional—but please bring your latest draft.”

***

### Part 3: Constrained Creative Writing (Literary Fiction)

The coffee maker hissed like a bird that had been promised water and given air instead. She measured the grounds carefully, two scoops, no more, the same as every morning. The filter sat in its cradle like a second skin, unfolded and waiting, and the tap ran a little longer than it needed to, clouding the glass with steam.

In the other room, the washing machine clicked into its final spin, the rhythm more familiar than his breathing used to be. She folded the shirt he had left on the floor, the one he wore when he thought no one was watching, the one that smelled like bus rides and late meetings and the subtle perfume of someone who had forgotten they were still being noticed.

The coffee bloomed in the carafe, the color deepening like a bruise, and she watched the liquid rise, slow and deliberate, as if the machine were reluctant to finish. The shirt in her hands had one button missing, the thread caught on something, somewhere. She pressed the tip of her thumb into the empty space where the button had been, feeling the hollow warmth of skin that no longer pressed against it.

Outside, the neighbor’s cat crossed the lawn, stopping to sniff at nothing, then padding on. The coffee finished, the machine clicked off, and she poured two cups out of habit, carrying one to the table where he used to sit and hadn’t in weeks. The other remained on the counter, cooling, until the drip of the faucet filled the silence between them.

***

### Part 4: Constrained Creative Writing (Hard Science Fiction)

The mid‑journey coolant‑loop audit stretched on past midnight by the ship’s artificial clock. Kanika stood inside the elbow of the primary heat‑exchanger manifold, mouthpiece of her suit clipped to the hard‑line, listening to the faint, uneven burr of the secondary pumps. The generation ship was 200 years into its 400‑year voyage, and the engineering log had been quietly reporting a 0.7% imbalance in the forward radiators for three weeks.

The problem was simple in theory: the ship’s passive radiators, laid out in broad fins along the outer hull, were losing efficiency at a rate that matched neither degradation nor expected dust‑impact profiles. The issue was a subtle impedance mismatch in the phase‑change material slurry, where the polymer‑suspended microcapsules that carried heat away from the reactor were beginning to clump. The resulting micro‑viscous pockets created uneven thermal gradients, which in turn caused the primary coolant pumps to compensate by pushing harder, wearing them down faster.

The ship carried a “quantum‑lattice” phase‑sensing array—a plausible extension of distributed fiber‑optic sensors—that could map the micro‑structure of the slurry in real time, but it had been installed as a research experiment, not a core system. Kanika could reroute its output to the engineering core, giving her a precise map of the clogs, but doing so would require quarantining sections of the lattice, temporarily reducing the array’s ability to monitor structural strain in the hull.

The moral choice sat like a cold knot in her chest: prioritize the smooth, long‑term functioning of the life‑support radiators, or protect the hull‑integrity monitoring that had kept the ship from catastrophic micro‑fracturing for the last century. The forward radiators would last another decade at best; the hull would be fine for another fifty, but only if the lattice ran at full resolution. She reached for the console, fingers hovering over the reroute command, painfully aware that every second she delayed meant another fraction of a degree of heat trapped in the core.

***

### Part 5: Constrained Creative Writing (Satire)

**Internal Memo: AI Ethics Board – Policy Draft v4.3**

To: All AI Product Leads  
From: AI Ethics Oversight Committee  
Subject: Updated Guidelines on AI‑Driven Idea Attribution and Credit Allocation

Effective immediately, all AI‑assisted proposals and deliverables must be accompanied by a standardized “Attribution Confidence Matrix” (ACM), which quantifies the probability that any given idea originated from a human employee, the AI model, or ambiguous ideation pathways. The ACM must be submitted before any external presentation or publication, and reviewed by the AI Ethics Board at least 72 hours prior.

To ensure fairness and transparency, the following policy applies:  
- In cases where the AI model reproduces a previously undocumented idea expressed only in informal team conversations, the idea will be attributed to the employee whose Slack handle alphabetically appears first among the participants.  
- If the employee’s name is not verifiable in the audit log, the AI model shall be credited as the originator, with the employee receiving a “Serendipity Bonus” in the form of no additional compensation.

Furthermore, the Board reminds all teams that AI‑assisted brainstorming sessions must be conducted in a designated “AI‑Thought Neutral Zone,” where all recordings are encrypted and scrubbed of vocal inflections, pauses, and emotional subtext. This ensures that no unintended bias can be traced back to the humans involved.

We thank you for your continued commitment to ethical innovation and to the creation of a workplace where credit is distributed algorithmically, not emotionally.

***

### Part 6: Poetry

**Meter:** Iambic tetrameter (four iambic feet per line).  

You reach the name, it hovers near,  
a shape you know, but cannot speak,  
your tongue a stone, your thoughts unclear,  
the air is thick, the silence deep.  

A beat, a pause, and then it slips—  
as if the word had never been.  
You watch the room, the faces rip  
through layers of a thin, thin skin.  

The laugh that follows, sharp and light,  
a joke that tries to smooth the space,  
yet in that gap, that fleeting night,  
you feel the outline of a face  

you loved, or lost, or never knew,  
and all at once it’s gone, too far—  
the name, the name, the missing clue,  
the ghost of someone you would bar  

from memory, but now recall  
as suddenly as if they stood  
beside you on the empty wall,  
the room you left behind for good.  

***

### Part 7: Code Generation with Hidden Complexity

```python
from typing import Any, Callable, Dict, Set, Tuple
from collections.abc import Hashable

# We will:
# - Transform all primitive values (str, int, float, bool, None) using the given function.
# - Decide to transform None by default, but make this explicit.
# - Handle circular references via an id‑based seen set.
# - Preserve structure (dicts, lists, tuples, sets) and nested containers.
# - Treat frozensets and tuple‑valued dict keys as normal data.

def deep_transform(
    obj: Any,
    transform_fn: Callable[[Any], Any],
    *,
    seen: Set[int] = None
) -> Any:
    """
    Recursively apply transform_fn to all primitive values (str, int, float, bool, None),
    while preserving the structure of nested containers (dict, list, tuple, set).

    Handles circular references by tracking object IDs.
    Preserves tuple‑valued dict keys and sets containing frozensets.

    Arguments:
      obj: data structure (dict, list, tuple, set, or primitive)
      transform_fn: function mapping Any -> Any
      seen: internal set of visited object IDs (used for cycles; do not pass explicitly)

    Returns:
      New object with transformed primitives and same structure.
    """
    if seen is None:
        seen = set()

    # If obj is None, treat it as a primitive and transform.
    if obj is None:
        return transform_fn(obj)

    # If obj is not a container, treat as primitive.
    if not isinstance(obj, (dict, list, tuple, set)):
        return transform_fn(obj)

    # If obj is mutable and has cycles, avoid infinite recursion.
    obj_id = id(obj)
    if obj_id in seen:
        return obj

    seen.add(obj_id)

    # Handle dicts (including tuple keys).
    if isinstance(obj, dict):
        result = {}
        for key, value in obj.items():
            # Transform the key if it's not a container (e.g., tuple of primitives).
            new_key = deep_transform(key, transform_fn, seen=seen)
            new_value = deep_transform(value, transform_fn, seen=seen)
            result[new_key] = new_value
        return result

    # Handle lists (mutable).
    if isinstance(obj, list):
        return [deep_transform(x, transform_fn, seen=seen) for x in obj]

    # Handle tuples (immutable).
    if isinstance(obj, tuple):
        return tuple(
            deep_transform(x, transform_fn, seen=seen) for x in obj
        )

    # Handle sets and frozensets.
    if isinstance(obj, set):
        # Sets cannot contain unhashable dicts/lists, but can contain frozensets.
        # Transform the contained elements.
        transformed = set()
        for x in obj:
            # For frozensets, deep_transform is safe because they are immutable.
            new_x = deep_transform(x, transform_fn, seen=seen)
            transformed.add(new_x)
        return transformed

    # Fallback: if we somehow get another type, treat as primitive.
    return transform_fn(obj)


# Example transform_fn that capitalizes strings and doubles numbers.
def example_transform(x: Any) -> Any:
    if isinstance(x, str):
        return x.upper()
    if isinstance(x, (int, float)):
        return x * 2
    if isinstance(x, bool):
        return not x
    return x

# Example usage:
# data = {"nested": [{"a": 1, 2: {3, frozenset({4, 5})}}, (None, "hello")]}
# result = deep_transform(data, example_transform)
```

**Justification notes:**

- `None` is treated as a primitive and transformed because excluding it would create an arbitrary special case and complicate the logic; the caller can supply a `transform_fn` that ignores `None` if desired.  
- Circular references are handled by tracking `id(obj)` in the `seen` set, preventing infinite recursion.  
- The function preserves exact structure (dicts stay dicts, lists stay lists, tuples stay tuples, sets stay sets) and correctly handles nested containers, including sets containing frozensets and tuple‑valued dict keys.  
- The interface is explicit and avoids side‑effects; the original object is not modified.

***

### Part 8: Logical Reasoning Under Constraints

Assign Ada, Brian, Carmen, Dev, Elena to projects API, Backend, Cloud under the constraints:

1. Each project needs at least one developer.
2. Ada and Brian cannot be on the same project.
3. Carmen works only if Elena is also on the same project.
4. Dev must work on API or Cloud, not Backend.
5. Backend needs exactly two developers.
6. Brian and Dev should be on the same project if possible (a preference, not a hard constraint).
7. If Cloud has only one developer, that developer must be Ada (only Ada is qualified).

We first note that Backend must have exactly two developers, and Dev cannot be on Backend, so Dev must be either on API or on Cloud. [cio](https://www.cio.com/article/3509174/ai-coding-assistants-wave-goodbye-to-junior-developers.html)
Also, each project must have at least one developer, and there are five people and three projects. [sourcegraph](https://sourcegraph.com/blog/revenge-of-the-junior-developer)

Because Backend must have two people, the remaining three are split between API and Cloud. [addyo.substack](https://addyo.substack.com/p/ai-wont-kill-junior-devs-but-your)

Let’s consider cases by Dev’s assignment.

***

**Case A: Dev on API**

Then Dev is on API; Dev cannot be on Backend. [cio](https://www.cio.com/article/3509174/ai-coding-assistants-wave-goodbye-to-junior-developers.html)
Cloud must have at least one developer, and Backend must have exactly two. [sourcegraph](https://sourcegraph.com/blog/revenge-of-the-junior-developer)

We want to satisfy:

- Ada and Brian not on the same project. [reddit](https://www.reddit.com/r/webdev/comments/1nhz953/anyone_else_think_ai_coding_assistants_are_making/)
- Carmen only if Elena is on same project. [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)
- If Cloud has only one developer, that developer must be Ada. [reddit](https://www.reddit.com/r/AskPhysics/comments/1nc4x0w/whats_the_theoretical_fastest_humans_could_travel/)

Try assigning Cloud to have one developer. [reddit](https://www.reddit.com/r/AskPhysics/comments/1nc4x0w/whats_the_theoretical_fastest_humans_could_travel/)
Then, by, Ada must be on Cloud. [reddit](https://www.reddit.com/r/AskPhysics/comments/1nc4x0w/whats_the_theoretical_fastest_humans_could_travel/)
So:  
- Ada → Cloud  
- Dev → API  

Then Backend must have two people, and the remaining people are: Brian, Carmen, Elena.  
Backend must contain exactly two of Brian, Carmen, Elena.  

Consider: Can Carmen be on Backend?  
If Carmen is on Backend, then Elena must also be there (by ). [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)
So one Backend option is: Carmen + Elena on Backend.  
Then Brian goes to API.  

Check constraints:

- Ada and Brian: Ada on Cloud, Brian on API → not on same project → OK. [reddit](https://www.reddit.com/r/webdev/comments/1nhz953/anyone_else_think_ai_coding_assistants_are_making/)
- Carmen on Backend; Elena on Backend → same project → OK. [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)
- Dev on API → not on Backend → OK. [cio](https://www.cio.com/article/3509174/ai-coding-assistants-wave-goodbye-to-junior-developers.html)
- Backend has exactly two: Carmen and Elena → OK. [addyo.substack](https://addyo.substack.com/p/ai-wont-kill-junior-devs-but-your)
- Cloud has only one (Ada) → Ada is on Cloud → OK. [reddit](https://www.reddit.com/r/AskPhysics/comments/1nc4x0w/whats_the_theoretical_fastest_humans_could_travel/)
- Each project has at least one:  
  - API: Dev, Brian  
  - Backend: Carmen, Elena  
  - Cloud: Ada → OK. [sourcegraph](https://sourcegraph.com/blog/revenge-of-the-junior-developer)

This assignment is valid:

- API: Dev, Brian  
- Backend: Carmen, Elena  
- Cloud: Ada  

We also asked whether Brian and Dev can be on the same project if possible. [1kosmos](https://www.1kosmos.com/resources/blog/asymmetric-encryption)
Here Brian is on API with Dev, so they are on the same project → preference satisfied. [1kosmos](https://www.1kosmos.com/resources/blog/asymmetric-encryption)

Now, is there another valid assignment?

Try giving Cloud two people instead, so  doesn’t force Ada to be the only one. [reddit](https://www.reddit.com/r/AskPhysics/comments/1nc4x0w/whats_the_theoretical_fastest_humans_could_travel/)

Subcase A1: Dev on API, Cloud has two people.  
Then by, Backend must have two, API has the remaining one. [addyo.substack](https://addyo.substack.com/p/ai-wont-kill-junior-devs-but-your)

Total people: 5  
- Backend: 2  
- API: 1  
- Cloud: 2  

Dev is on API → API must have only Dev.  
So API: Dev.  

Then Backend and Cloud share Ada, Brian, Carmen, Elena (4 people), with 2 in Backend and 2 in Cloud.  

Suppose Ada on Cloud (which is fine, since  doesn’t apply when Cloud has more than one). [reddit](https://www.reddit.com/r/AskPhysics/comments/1nc4x0w/whats_the_theoretical_fastest_humans_could_travel/)

Now, constraints:

- Ada and Brian must not be on same project. [reddit](https://www.reddit.com/r/webdev/comments/1nhz953/anyone_else_think_ai_coding_assistants_are_making/)
- Carmen only if Elena is on same project. [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)

Try putting Brian on Backend.  

Then Ada cannot be on Backend → Ada must be on Cloud.  
So:

- Ada → Cloud  
- Brian → Backend  
- Dev → API  

Remaining: Carmen, Elena for Backend and Cloud.  
Backend already has Brian; needs one more.  
Cloud has Ada; needs one more.  

Option 1: Carmen → Backend, Elena → Cloud.  
Then Carmen is on Backend, Elena is on Cloud → different projects → Carmen cannot be on Backend without Elena there → violates. [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)

Option 2: Carmen → Cloud, Elena → Backend.  
Then Carmen on Cloud, Elena on Backend → again different projects → Carmen cannot be on Backend without Elena there → violates. [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)

Option 3: Carmen and Elena both on Backend.  
Then Carmen and Elena on Backend → OK for. [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)
Backend: Brian, Carmen, Elena → 3 people → violates  (Backend must have exactly two). [addyo.substack](https://addyo.substack.com/p/ai-wont-kill-junior-devs-but-your)

Option 4: Carmen and Elena both on Cloud.  
Then Carmen and Elena on Cloud → OK for. [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)
Cloud: Ada, Carmen, Elena → 3 people → violates our subcase that Cloud has 2.  

So, in this branch, no valid assignment exists when Dev is on API and Cloud has two people.  

Subcase A2: Dev on API, Cloud has three people.  
Then Backend must have only two people, and API has only Dev.  
Cloud has three out of Ada, Brian, Carmen, Elena.  

But there are only four people besides Dev, so Cloud cannot have three without leaving one for Backend and one for API—but API already has Dev, so API can have only Dev.  

Thus Backend must have two people, chosen from the remaining four.  

We can’t force  to fail immediately, but let’s try: [blog.robbowley](https://blog.robbowley.net/2025/02/11/are-we-undervaluing-the-benefit-of-junior-developers/)

Suppose Ada on Cloud, Brian on Cloud.  
Then Ada and Brian on same project → violates. [reddit](https://www.reddit.com/r/webdev/comments/1nhz953/anyone_else_think_ai_coding_assistants_are_making/)

So if Ada is on Cloud, Brian cannot be.  

Suppose Ada on Cloud, Brian on Backend.  
Then Carmen and Elena must be split so that if Carmen is on Backend, Elena is there too; similarly for