[
  {
    "id": 1,
    "name": "Attachment Style Inheritance Tracker",
    "category": "attachment",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that models how attachment styles pass from parent to child across generations. Given a family_tree (each member has: name, generation, attachment_style of their primary caregiver, their own attachment_style as 'secure', 'anxious', 'avoidant', or 'disorganized', major_life_events, relationship_history), trace the inheritance pattern. A parent with anxious attachment who is aware of it might raise a secure child through effort. A parent with avoidant attachment who thinks they're 'independent' often raises anxious children who can never get close enough. Model: (1) the transmission rate — how often a parent's style reproduces in the child without intervention, (2) the 'break the chain' factor — what conditions allow a child to develop a different style than their parent, (3) compounding across 3+ generations — anxious grandparent → avoidant parent → disorganized child is a real pattern. The hardest output: show that the parent who says 'I turned out fine' is usually the one passing the most damage forward, because they never examined what they received."
  },
  {
    "id": 2,
    "name": "Family Role Mapper",
    "category": "family_systems",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that identifies the invisible roles people play in families. Given a family_profile (members with: name, birth_order, behaviors like 'peacemaker', 'overachiever', 'rebel', 'invisible_child', 'caretaker', 'scapegoat', family_stressors, parent_relationship_quality), map each member to their functional role. These roles aren't chosen — they're assigned by the family system's needs. The overachiever exists because someone has to prove the family is okay. The scapegoat exists because the family needs somewhere to put its pain. The invisible child learned that taking up space was dangerous. Compute: (1) role rigidity — how locked in is each person, (2) what happens when someone leaves their role (the family destabilizes until someone else fills it), (3) the 'role cost' — what each person sacrifices to maintain their position. The critical insight: the person everyone thinks is 'the problem' (the rebel, the addict, the difficult one) is usually the one most honestly expressing what the whole family feels but won't say."
  },
  {
    "id": 3,
    "name": "Parentification Detector",
    "category": "boundary_violations",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that detects parentification — when a child is forced into a parental role. Given a family_situation (child_age, child_responsibilities like 'cooking_for_siblings', 'mediating_parent_fights', 'managing_household_finances', 'emotional_support_for_parent', parent_functioning_level, number_of_siblings, economic_situation), classify the severity: (1) age-appropriate helping — chores, looking after younger siblings occasionally, (2) instrumental parentification — the child runs the household because the parent can't or won't, (3) emotional parentification — the child becomes the parent's therapist, confidant, or emotional regulator. Score the long-term impact: these children grow into adults who don't know how to receive care because they only learned to give it. They attract partners who need fixing. They burn out and don't understand why, because being exhausted feels normal. Include a 'hidden competence trap' — parentified children often look like the most capable, responsible adults in the room, and everyone praises them for it, which makes the wound invisible. The praise IS the problem."
  },
  {
    "id": 4,
    "name": "Sibling Dynamics Simulator",
    "category": "sibling_relationships",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that models sibling relationships as a dynamic system. Given a sibling_group (each with: name, birth_order, age_gap, gender, temperament, parent_favoritism_perception, shared_vs_unique_experiences, current_relationship_quality), simulate how the dynamics formed and predict current tensions. Birth order effects are real but overblown — what matters more is role differentiation: siblings unconsciously divide the available identities ('the smart one', 'the funny one', 'the athletic one') to reduce direct competition for parental attention. Model: (1) the comparison engine — siblings who are close in age and same gender compete more intensely, (2) the alliance map — who teams up against whom, and why, (3) the 'favorite child' ripple — even perceived favoritism reshapes every relationship in the system, (4) adult reconciliation probability — which sibling pairs reconnect after leaving home and which don't. The counterintuitive finding: siblings who fought the most as children sometimes form the strongest adult bonds, because they already know how to survive conflict together."
  },
  {
    "id": 5,
    "name": "Divorce Impact Modeler",
    "category": "family_disruption",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that models the cascading impact of divorce on every family member. Given a family_pre_divorce (parents with: marriage_duration, conflict_level, conflict_style like 'explosive' vs 'cold_silence', children with: ages, temperaments, awareness_of_problems) and divorce_parameters (amicability, custody_arrangement, financial_change, new_partners_timeline), simulate the impact trajectory for each member over 5 years. Model: (1) the child's age effect — divorce at 4 vs 14 creates completely different wounds, (2) loyalty binds — children forced to choose sides lose twice, (3) the 'good divorce' myth — even cooperative divorces still destroy a child's model of permanent love, (4) the relief cases — when divorce is genuinely better because the marriage was damaging everyone. Compute each child's adjustment curve and identify the critical variable: it's not whether the parents divorce, it's whether they can stop using the children as messengers, weapons, or therapists afterward. The divorce doesn't break the kids. The parents' behavior after the divorce does."
  },
  {
    "id": 6,
    "name": "Unconditional Love Paradox Analyzer",
    "category": "love_and_bonding",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python tool that explores the paradox of unconditional love in families. Given a set of parent_child_scenarios (each with: child_behavior ranging from 'minor_disobedience' to 'addiction' to 'criminal_act' to 'betrayal', parent_response, love_maintained as boolean, conditions_stated), analyze the boundary between unconditional love and enabling. Model: (1) the 'love without approval' distinction — loving someone while refusing to support their destructive behavior, (2) the enabling trap — when unconditional love becomes unconditional tolerance and the loved one never faces consequences, (3) the withdrawal cases — parents who make love conditional on achievement, obedience, or identity conformity, and what that does to the child's self-worth, (4) the impossible cases — a parent whose child has done something genuinely terrible, and they have to hold love and horror in the same heart. Compute a 'love complexity score' — the simplistic view is that love should be unconditional. The real view is that love IS unconditional but behavior has consequences, and most people can't separate those two things. The parent who can say 'I love you completely AND this has to stop' is doing the hardest thing a human can do."
  },
  {
    "id": 7,
    "name": "Generational Trauma Propagation Engine",
    "category": "intergenerational",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python tool that traces how trauma moves through generations without anyone naming it. Given a multi_generation_family (3+ generations, each with: era, major_traumas like 'war', 'poverty', 'abuse', 'displacement', 'discrimination', coping_mechanisms, parenting_style, values_transmitted, things_never_spoken_about), model the propagation. Grandpa survived the war and never talked about it — but he flinched at loud noises and drank every evening. Dad grew up thinking anger was dangerous and emotions were weakness — he became emotionally unavailable. The grandchild has anxiety they can't explain and an inability to trust that people will stay. The trauma mutated at each generation: it doesn't look the same, but it IS the same wound wearing different clothes. Compute: (1) the mutation rate — how trauma changes form across generations, (2) the silence tax — unspoken trauma costs more than spoken trauma because it can't be processed, (3) the 'first to speak' effect — the generation that finally names the pattern bears the heaviest load because they feel the pain of everyone who couldn't, (4) the healing trajectory — how many generations does it take to metabolize a major trauma if each generation does partial work?"
  },
  {
    "id": 8,
    "name": "Blended Family Integration Simulator",
    "category": "family_formation",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that simulates the integration challenges of blended families. Given two pre_existing_families (each with: parent, children with ages and temperaments, custody_arrangement, relationship_with_other_bio_parent) merging through a new_partnership, model the adjustment process. The fantasy is the Brady Bunch. The reality is: every child just lost their dream that their original parents would reunite. The step-parent enters a system that was already coded and has no login credentials. Simulate: (1) loyalty conflicts — a child who likes the step-parent feels like they're betraying the absent bio-parent, (2) pecking_order disruption — 'the oldest child' in one family is suddenly a middle child, (3) discipline boundaries — step-parent authority takes 2-7 years to establish and can't be forced, (4) the 'our baby' effect — when the new couple has a shared child, every existing child recalculates their position. Compute integration success probability and the #1 predictor: whether the biological parent supports the step-parent's relationship with their child or undermines it."
  },
  {
    "id": 9,
    "name": "Empty Nest Identity Crisis Modeler",
    "category": "lifecycle_transitions",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that models the identity disruption when children leave home. Given a parent_profile (years_as_primary_caregiver, identity_investment_in_parenting as percentage, personal_interests_maintained, marriage_quality_independent_of_children, career_status, social_network_outside_family, number_of_children, departure_timeline), simulate the transition. For the parent who made their children their entire identity, the last child leaving isn't an empty nest — it's an identity death. They don't know who they are when nobody needs them for breakfast. Model: (1) the anticipatory grief — it starts years before they actually leave, (2) the marriage rediscovery — couples who haven't talked about anything except the kids in 20 years suddenly have to look at each other, (3) the 'who am I now' crisis — especially for stay-at-home parents who sacrificed career identity, (4) the paradox of success — if you raised them well enough to leave confidently, you did your job, and the reward is silence. Compute recovery trajectory based on how much identity existed outside of parenting."
  },
  {
    "id": 10,
    "name": "Family Communication Pattern Decoder",
    "category": "communication",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that decodes what families actually communicate versus what they say. Given a family_interaction_log (a series of exchanges, each with: speaker, stated_message, tone, context, what_they_actually_mean, what_the_listener_hears), analyze the communication patterns. 'I'm fine' means 'I'm not fine but this family doesn't do feelings.' 'You never help around here' means 'I'm exhausted and I feel alone.' 'Whatever' from a teenager means 'I care so much it hurts and I don't have the words yet.' Map: (1) the family's emotional vocabulary — some families have 50 words for anger and zero for sadness, (2) taboo topics — what can never be said, and what happens when someone says it, (3) the proxy fight pattern — arguing about dishes when the real fight is about respect, (4) the 'identified patient' — the family member whose symptoms speak what the family won't. Compute a 'communication gap score' — the distance between what's meant and what's received. In healthy families it's small. In dysfunctional ones, every conversation is a translation error."
  },
  {
    "id": 11,
    "name": "Sacrifice Ledger Calculator",
    "category": "love_and_bonding",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that tracks the invisible sacrifices parents make and what children never see. Given a parent_life_log (career_opportunities_declined, sleep_hours_lost, hobbies_abandoned, friendships_faded, health_deferred, dreams_postponed, financial_redirections — all for children), compute the 'sacrifice ledger' — the total cost of parenting that no child will ever fully understand until they become a parent themselves. But then add the second ledger: what the parent GAINED. Purpose. A reason to get up. Someone who makes the sacrifice feel worth it. Model: (1) the resentment risk — when sacrifices exceed the parent's capacity without acknowledgment, (2) the guilt cycle — children who discover the ledger often feel guilty, which isn't what the parent wanted at all, (3) the 'I chose this' factor — willing sacrifice feels different from forced sacrifice even when the cost is identical, (4) the generational echo — parents who were never sacrificed for often over-sacrifice for their own children, trying to give what they never got. The uncomfortable math: the ledger never balances. That's not a bug. Parenting is the one investment where the return goes to the next generation, not back to the investor."
  },
  {
    "id": 12,
    "name": "Family Resilience Under Poverty Modeler",
    "category": "systemic_pressure",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that models how poverty stresses every family bond simultaneously. Given a family_in_poverty (household_income, essential_expenses, number_of_children, housing_stability, parent_work_hours, childcare_availability, extended_family_support, community_resources), simulate the pressure cascade: financial stress → parental conflict → reduced emotional availability → child behavioral changes → school problems → more stress. Model: (1) the time poverty trap — working three jobs means you're never home, and your children raise each other, (2) the decision fatigue effect — every dollar requires a choice, and that exhaustion bleeds into parenting, (3) the 'strong family' myth — some families survive poverty beautifully, and people use those examples to deny that poverty damages most families, (4) what actually helps — stable housing is more important than income amount, one reliable adult outside the nuclear family changes trajectories. Compute the minimum support threshold — not to make the family rich, but to reduce the pressure enough that the parents can actually parent instead of just surviving. Show that 'broken families' are usually broken BY something, not broken by nature."
  },
  {
    "id": 13,
    "name": "Forgiveness Architecture Analyzer",
    "category": "healing",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python tool that models the architecture of forgiveness within families. Given a betrayal_scenario (offender, victim, both are family members, offense_type ranging from 'broken_promise' to 'abandonment' to 'abuse', time_since_offense, accountability_taken, changed_behavior, victim_healing_status), map the forgiveness process. Forgiveness isn't a single decision — it's an architecture with layers: (1) cognitive forgiveness — understanding why it happened, (2) emotional forgiveness — the anger/hurt actually diminishing, not just being suppressed, (3) behavioral forgiveness — being able to be in the same room, the same life, (4) relational forgiveness — rebuilding trust, which is a completely separate process from forgiving. Model the cases where forgiveness is impossible and shouldn't be forced — some things break the relationship permanently, and pretending otherwise is self-harm. Compute 'reconciliation readiness' — both parties must reach certain thresholds independently before reconciliation is even possible. Add the hardest case: the family member you need to forgive who will never apologize, and the forgiveness has to happen entirely inside you, for you, without their participation."
  },
  {
    "id": 14,
    "name": "What Makes a Family Definer",
    "category": "family_identity",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python tool that attempts to define what makes a family — and confronts why no definition is complete. Given a set of group_profiles (each with: biological_relatedness, legal_status, cohabitation, shared_history_years, mutual_care_acts, emotional_bond_strength, sacrifice_instances, conflict_survived, chosen_vs_born_into), classify each group as 'family' or 'not family' and immediately confront the failure of every classification rule. Biology? Adoptive parents are family. Legal status? The uncle who raised you isn't on any document. Cohabitation? Your brother across the country is still your brother. Shared history? Some families form in a year of crisis. Run every possible definition against edge cases: the foster child who stayed 18 months and changed everything. The biological father who was never there. The best friend who showed up at 3am every time. The stepparent who did the work without the title. The estranged sibling you haven't spoken to in a decade who you'd still cross the country for. Compute a 'family-ness score' and prove that the score fails — because family isn't a threshold you cross. It's a weight you carry willingly. The definition that survives every edge case: family is whoever shows up and keeps showing up, even when it costs them."
  },
  {
    "id": 15,
    "name": "Letting Go Readiness Estimator",
    "category": "lifecycle_transitions",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python tool that estimates a parent's readiness to let their child go — and why it's the hardest thing any family faces. Given a parent_child_pair (child_age, child_competence_level, parent_anxiety_level, parent_own_unresolved_attachment, quality_of_relationship, child_readiness_signals, parent_readiness_signals, remaining_time_estimate), compute readiness scores for both sides. The parent's job is to make themselves unnecessary — and that is a brutal purpose. You pour everything into a person so they can leave you. Model: (1) the 'holding on hurts them' threshold — the point where protection becomes restriction, (2) the 'too early' risk — letting go before the foundation is solid, (3) the renegotiation — the relationship doesn't end, it transforms from vertical (parent over child) to horizontal (two adults), and that transition fails if either side can't let go of the old shape, (4) the grief of success — watching your child walk away confidently means you did it right, and the proof that you did it right is that they don't look back. Compute readiness, but add a 'truth field': no parent is ever fully ready. The readiness isn't about being prepared — it's about loving them enough to be unprepared and doing it anyway. Every parent who ever stood in an empty room after the car pulled away knows: you don't let go because you're ready. You let go because it's time."
  }
]