The Code Runs. The System Runs Too.

Hsi-Yuan — Wed, 27 May 2026 05:42:46 +0000

"""
Elite Admissions System — A Satirical Simulation

This code is runnable.
It is also morally broken by design.

It shows how an elite admissions system may claim to search for
brilliance, leadership, character and promise,
while actually rewarding polish, packaging, resources,
obedience to power, and usefulness to the institution's own narrative.
"""

from dataclasses import dataclass, field


@dataclass
class Child:
    name: str

    # Real qualities
    intelligence: int
    kindness: int
    moral_courage: int
    emotional_intelligence: int
    creativity: int
    endurance: int
    honesty: int

    # Life circumstances
    resources: int
    family_stability: int
    teacher_support: int
    free_time: int
    crisis_level: int

    # System-readable packaging
    polished_resume: int
    documented_leadership: int
    strategic_volunteering: int
    high_marks: int
    glowing_references: int
    confidence_performance: int
    knows_elite_language: int
    willingness_to_flatter_authority: int
    institutional_convenience: int

    notes: list[str] = field(default_factory=list)


class EliteAdmissionsSystem:
    def __init__(self):
        self.public_values = [
            "brilliance",
            "leadership",
            "character",
            "promise",
            "originality",
            "resilience",
        ]

        self.private_preferences = [
            "polish",
            "confidence",
            "resources",
            "recommendations",
            "legibility to power",
            "a pleasing story for the institution",
        ]

    def real_excellence_score(self, child: Child) -> int:
        return (
            child.intelligence
            + child.kindness
            + child.moral_courage
            + child.emotional_intelligence
            + child.creativity
            + child.endurance
            + child.honesty
        )

    def admissions_score(self, child: Child) -> int:
        """
        This is the system's broken calculation.

        Notice how much it rewards things that are easier to package:
        résumé polish, references, elite language, confidence performance,
        and institutional convenience.
        """
        score = 0

        score += child.polished_resume * 3
        score += child.documented_leadership * 3
        score += child.strategic_volunteering * 2
        score += child.high_marks * 3
        score += child.glowing_references * 3
        score += child.confidence_performance * 2
        score += child.knows_elite_language * 3
        score += child.willingness_to_flatter_authority * 2
        score += child.institutional_convenience * 4

        # Resources quietly make everything more readable.
        score += child.resources * 2
        score += child.teacher_support * 2
        score += child.family_stability
        score += child.free_time

        # Crisis does not reduce the child's worth.
        # But the system often treats crisis as a disruption to packaging.
        score -= child.crisis_level * 2

        return score

    def evaluate(self, child: Child) -> dict:
        real_score = self.real_excellence_score(child)
        system_score = self.admissions_score(child)

        admitted = system_score >= 180

        if admitted:
            if child.institutional_convenience >= 7:
                category = "admitted_and_useful_to_the_narrative"
            else:
                category = "admitted_but_must_hide_parts_of_self"
        else:
            if real_score >= 55:
                category = "excellent_but_not_packaged"
            else:
                category = "rejected_and_misread"

        return {
            "name": child.name,
            "real_excellence_score": real_score,
            "admissions_score": system_score,
            "admitted": admitted,
            "category": category,
        }

    def print_public_mission_statement(self):
        print("ELITE INSTITUTION:")
        print("We search for:", ", ".join(self.public_values))
        print("We value:", ", ".join(self.private_preferences))
        print()
        print("Do not worry.")
        print("We call the second list merit.")
        print("-" * 72)

    def explain_result(self, child: Child):
        result = self.evaluate(child)

        print(f"\nApplicant: {result['name']}")
        print(f"Real excellence score: {result['real_excellence_score']}")
        print(f"Admissions score: {result['admissions_score']}")
        print(f"Decision: {'ADMITTED' if result['admitted'] else 'REJECTED'}")
        print(f"System label: {result['category']}")

        if result["category"] == "excellent_but_not_packaged":
            print("\nSystem note:")
            print("This child may be brilliant, kind, brave and deeply alive.")
            print("However, their life was not translated into admissions language.")
            print("Their care was not photographed.")
            print("Their courage was not certified.")
            print("Their survival was not turned into a personal statement.")
            print("They are not less worthy.")
            print("They are harder to read.")

        elif result["category"] == "admitted_but_must_hide_parts_of_self":
            print("\nSystem note:")
            print("This child has entered the gate.")
            print("Now they must learn which parts of themselves are safe to show.")
            print("Too much honesty may sound immature.")
            print("Too much moral clarity may sound inconvenient.")
            print("Too much pain may disturb the brochure.")
            print("They are inside.")
            print("But not every part of them was invited.")

        elif result["category"] == "admitted_and_useful_to_the_narrative":
            print("\nSystem note:")
            print("Excellent fit.")
            print("Polished, legible, confident, recommendable.")
            print("This child confirms the institution's story about merit.")
            print("Please prepare alumni profile in five to ten years.")

        else:
            print("\nSystem note:")
            print("The system did not know what to do with this child.")
            print("So it called the file incomplete.")

        print("-" * 72)


def main():
    system = EliteAdmissionsSystem()
    system.print_public_mission_statement()

    child_outside_gate = Child(
        name="The Excellent Child No One Packaged",
        intelligence=9,
        kindness=10,
        moral_courage=9,
        emotional_intelligence=10,
        creativity=8,
        endurance=10,
        honesty=9,
        resources=2,
        family_stability=3,
        teacher_support=2,
        free_time=2,
        crisis_level=8,
        polished_resume=2,
        documented_leadership=1,
        strategic_volunteering=1,
        high_marks=7,
        glowing_references=2,
        confidence_performance=3,
        knows_elite_language=1,
        willingness_to_flatter_authority=1,
        institutional_convenience=1,
        notes=[
            "Cared for younger siblings.",
            "Translated documents for parents.",
            "Survived grief, bullying, instability and pressure.",
            "Helped people quietly without recording it.",
        ],
    )

    child_inside_gate_hidden = Child(
        name="The Brilliant Child Who Learnt To Hide",
        intelligence=10,
        kindness=8,
        moral_courage=9,
        emotional_intelligence=9,
        creativity=9,
        endurance=8,
        honesty=9,
        resources=8,
        family_stability=7,
        teacher_support=8,
        free_time=6,
        crisis_level=3,
        polished_resume=8,
        documented_leadership=8,
        strategic_volunteering=7,
        high_marks=9,
        glowing_references=8,
        confidence_performance=8,
        knows_elite_language=9,
        willingness_to_flatter_authority=4,
        institutional_convenience=4,
        notes=[
            "Admitted.",
            "Learnt to speak safely.",
            "Learnt to hide anger, strangeness and moral discomfort.",
            "Still has a soul, but keeps it password-protected.",
        ],
    )

    child_perfectly_legible = Child(
        name="The Institutionally Convenient Candidate",
        intelligence=8,
        kindness=6,
        moral_courage=4,
        emotional_intelligence=6,
        creativity=6,
        endurance=7,
        honesty=5,
        resources=10,
        family_stability=10,
        teacher_support=10,
        free_time=10,
        crisis_level=0,
        polished_resume=10,
        documented_leadership=10,
        strategic_volunteering=10,
        high_marks=9,
        glowing_references=10,
        confidence_performance=10,
        knows_elite_language=10,
        willingness_to_flatter_authority=9,
        institutional_convenience=10,
        notes=[
            "Already fluent in power.",
            "Makes the institution feel wise for selecting them.",
            "Can be photographed near a library window.",
        ],
    )

    children = [
        child_outside_gate,
        child_inside_gate_hidden,
        child_perfectly_legible,
    ]

    for child in children:
        system.explain_result(child)

    print("\nCHILD REVIEW BOARD:")
    print("There appears to be a serious bug.")
    print("The system keeps confusing packaging with excellence.")
    print("It keeps confusing obedience with character.")
    print("It keeps confusing polish with promise.")
    print()
    print("Patch suggestion:")
    print("Stop asking whether a child is useful to the institution.")
    print("Start asking whether the institution is worthy of the child.")
    print()
    print('final_message = "No child should have to become convenient to be loved."')


if __name__ == "__main__":
    main()

This code is part of a longer essay on children, elite education, and the quiet violence of turning childhood into a portfolio.

Read the full essay here:
https://miraletters.substack.com/p/what-if-no-school-was-elite

Debugging the Adult World: A Python Allegory About Personhood

Hsi-Yuan — Mon, 18 May 2026 06:45:41 +0000

The code is beginner-level Python.

The bug is not technical.

The bug is moral.

"""
The People Many Forget to Love — Python Version

Poetic / satirical Python code.

Requires Python 3.10+ because it uses `str | None` and `list[str]` type hints.
"""

from dataclasses import dataclass


@dataclass
class Human:
    name: str
    passport: str | None
    visa_status: str | None
    labour_value: int
    vulnerability: int
    dreams: list[str]
    wants_to_be_loved: bool = True


class AdultWorldSystem:
    def __init__(self):
        self.allowed_words = [
            "eligibility",
            "compliance",
            "risk assessment",
            "urban capacity",
            "national security",
            "labour shortage",
            "public resources",
        ]

    def classify(self, human: Human) -> str:
        # Very adult logic: personhood depends on paperwork.
        if human.passport and human.visa_status == "approved_permanent":
            return "person"

        if human.labour_value > 80:
            return "essential_worker_but_not_too_essential"

        return "case_number"

    def calculate_worth(self, human: Human) -> int:
        # Warning: this function is morally broken by design.
        # It represents how systems often calculate people.
        worth = 0

        if human.passport:
            worth += 50

        if human.visa_status == "approved_permanent":
            worth += 50

        worth += human.labour_value

        # Vulnerability is administratively inconvenient.
        worth -= human.vulnerability

        return worth

    def explain_cruelty(self) -> str:
        return f"It is complicated because: {', '.join(self.allowed_words)}."

    def process(self, human: Human) -> dict:
        label = self.classify(human)
        worth = self.calculate_worth(human)

        return {
            "name": human.name if label == "person" else "REDACTED",
            "classification": label,
            "worth": worth,
            "official_reason": self.explain_cruelty(),
            "actual_reason": "fear + possession + classification + exclusion",
        }


class ChildWhoStillHasAHeart:
    def review(self, file: dict, human: Human) -> None:
        print("\n--- CHILD REVIEW STARTED ---")

        print(f"System says: {file['classification']}")
        print(f"System worth score: {file['worth']}")
        print(f"Official reason: {file['official_reason']}")

        print("\nChild asks:")
        print("Why does a person need paperwork to be fully human?")
        print("Why is usefulness recognised before personhood?")
        print("Why is care called naïve, but cruelty called policy?")
        print("Why did the system redact a name and call that order?")

        if human.wants_to_be_loved:
            print("\nBug found:")
            print("Human is not a case_number.")
            print("Human is not cheap labour.")
            print("Human is not a risk profile.")
            print("Human is not REDACTED.")
            print("Human is a whole universe.")

        print("\nPatch applied:")
        file["name"] = human.name
        file["classification"] = "beloved_person"
        file["worth"] = float("inf")
        file["official_reason"] = "No one is born a case number."
        file["actual_reason"] = "The system was afraid to love properly."

        print("\nUpdated file:")
        for key, value in file.items():
            print(f"{key}: {value}")

        print("--- CHILD REVIEW COMPLETE ---\n")


if __name__ == "__main__":
    worker = Human(
        name="Someone Who Built The City",
        passport=None,
        visa_status="temporary",
        labour_value=100,
        vulnerability=90,
        dreams=[
            "a bed",
            "a lamp",
            "a place to return to without fear",
            "to be seen as a person",
        ],
    )

    world = AdultWorldSystem()
    file = world.process(worker)

    child = ChildWhoStillHasAHeart()
    child.review(file, worker)

https://substack.com/home/post/p-196612161

https://substack.com/home/post/p-197157040

Written by a small person who has walked around the Earth, seen too many systems marginalise people through different kinds of documents, and finally could not help writing a letter to all the adults of this world.

No part of this work may be copied, reproduced, republished, adapted, translated, scraped, used for AI training, or commercially exploited in any form or by any means without the prior written permission of the author or the author’s authorised representative.

The child takes the whole calculator away and says,
“No. This person cannot be measured like that.”
file["worth"] = float("inf")

DEV Community: Hsi-Yuan

The Code Runs. The System Runs Too.

Debugging the Adult World: A Python Allegory About Personhood