interactive-theatre-designer
Skill17 starsChanged 5 months agoApache-2.0Archived repositoryView on GitHub
Designs interactive theatrical experiences with branching narratives, audience participation systems, and immersive environmental storytelling.
1 other project uses a version of this.
Other versions1 project uses a version of this.
Word for word · 1
- organvm-iv-taxis/a-i--skills★ 17100% same
Edited · 0
None found.
Wrote their own version · 0
None found.
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository170 other files it gives its agents.
- AGENTS.mdAGENTS.md
- docs/AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- .github/copilot-instructions.mdCopilot instructions
- algorithmic-artSkill
- audio-engineering-patternsSkill
- canvas-designSkill
- creative-writing-craftSkill
- generative-art-algorithmsSkill
- generative-art-deploymentSkill
- generative-music-composerSkill
- modular-synthesis-philosophySkill
- movement-notation-systemsSkill
- narratological-algorithmsSkill
- natural-center-extractionSkill
- react-three-fiber-patternsSkill
- reality-tv-narrative-analyzerSkill
- script-analysis-dramaturgicalSkill
- theme-factorySkill
- three-js-interactive-builderSkill
- corpus-persona-extractionSkill
- data-ingestion-pipelineSkill
- data-pipeline-architectSkill
- data-storytelling-analystSkill
- market-gap-analysisSkill
- ml-experiment-trackerSkill
- prompt-atom-formalizationSkill
- sql-query-optimizerSkill
- systemic-product-analystSkill
- time-series-analystSkill
- accessibility-patternsSkill
- agent-testing-patternsSkill
- api-design-patternsSkill
- artifacts-builderSkill
- backend-implementation-patternsSkill
- browser-extension-patternsSkill
- cli-tool-designSkill
- code-refactoring-patternsSkill
- code-review-checklistSkill
- coding-standards-enforcerSkill
- community-platform-patternsSkill
- configuration-managementSkill
- continuous-learning-agentSkill
- data-backup-patternsSkill
- database-migration-patternsSkill
- deployment-cicdSkill
- docker-containerizationSkill
- dotfile-systems-architectSkill
- error-handling-logging-patternsSkill
- fastapi-patternsSkill
- feature-workflow-orchestratorSkill
- frontend-design-systemsSkill
- fullstack-starter-packSkill
- gcp-resource-optimizerSkill
- htmx-interaction-patternsSkill
- iterative-code-explorationSkill
- json-schema-designSkill
- mcp-builderSkill
- mcp-server-orchestratorSkill
- mobile-platform-architectSkill
- The first 60 shown.
The file
We split this skill into the rules it gives an agent
4 rules. About 0 are common, 4 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈4
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 174
Use time pressure sparingly and purposefully
- Distinctive: line 444
Block rehearsal: Test spacing and movement
- Distinctive: line 446
Integration: Run full show with choices
- Distinctive: line 448
Tech: Add all technical elements
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Interactive Theatre Designer
This skill provides guidance for creating theatrical experiences where audiences participate in, influence, or co-create the performance through interactive systems and branching narratives.
Core Competencies
- Branching Narrative: Multi-path story structures
- Audience Agency: Meaningful choice and participation
- Immersive Design: Environmental storytelling, site-specific work
- Live Systems: Real-time adaptation and emergence
- Hybrid Formats: Physical/digital integration
Interactive Theatre Fundamentals
Spectrum of Interactivity
Passive Active
│ │
├──Traditional──┬──Promenade──┬──Immersive──┬──Participatory──┤
│ Theatre │ Theatre │ Theatre │ Theatre │
│ │ │ │ │
│ Fixed seats │ Audience │ Audience │ Audience │
│ Fourth wall │ moves │ is inside │ affects │
│ No agency │ Partial │ story world │ narrative │
│ │ agency │ Some agency │ Full agency │
└───────────────┴─────────────┴─────────────┴─────────────────┘Participation Modes
| Mode | Description | Design Challenge |
| Witness | Observe from within | Manage sight lines, intimacy |
| Explorer | Choose where to go | Balance FOMO, reward curiosity |
| Player | Make story choices | Create meaningful stakes |
| Co-creator | Generate content | Scaffold creativity |
| Performer | Become a character | Lower inhibition barriers |
Branching Narrative Design
Structure Types
Linear with Variations
A ──→ B ──→ C ──→ D
↓
B' (variation based on earlier choice)
Branching Tree
┌── B1 ──→ C1
A ────┤
└── B2 ──→ C2 ──┬── D1
└── D2
Folding Paths (reconvergent)
┌── B1 ──┐
A ────┤ ├──→ D
└── B2 ──┘
Hub and Spoke
┌── B ──┐
┌────┤ │
A ──┤ └───────┘
│ ┌── C ──┐
└────┤ │
└───────┘
Parallel Threads
A1 ───────→ B1 ───────→ C1
↕ sync
A2 ───────→ B2 ───────→ C2Choice Architecture
class NarrativeChoice:
"""A decision point in the story"""
def __init__(self, prompt, options):
self.prompt = prompt
self.options = options
self.context_requirements = []
self.consequences = {}
def evaluate_options(self, audience_state):
"""Determine available choices based on state"""
available = []
for option in self.options:
if option.is_available(audience_state):
available.append(option)
# Always ensure at least two meaningful options
if len(available) < 2:
available.append(self._create_fallback_option())
return available
class StoryBeat:
"""A unit of narrative action"""
def __init__(self, content, duration_range, choice=None):
self.content = content
self.min_duration = duration_range[0]
self.max_duration = duration_range[1]
self.choice = choice # Optional NarrativeChoice
self.state_changes = {} # What this beat modifies
self.prerequisites = [] # What must be true to reach thisConsequence Systems
class ConsequenceTracker:
"""Track choices and their ripple effects"""
def __init__(self):
self.choices_made = []
self.world_state = {}
self.character_relationships = {}
self.available_endings = set()
def record_choice(self, choice_id, option_selected, timestamp):
self.choices_made.append({
'choice': choice_id,
'selected': option_selected,
'time': timestamp
})
self._apply_consequences(choice_id, option_selected)
self._update_available_endings()
def _apply_consequences(self, choice_id, option):
"""Apply immediate and delayed consequences"""
# Immediate effects
for effect in option.immediate_effects:
self._apply_effect(effect)
# Queue delayed effects
for effect in option.delayed_effects:
self._queue_effect(effect)
def get_story_fingerprint(self):
"""Unique identifier for this audience's journey"""
return hash(tuple(
(c['choice'], c['selected'])
for c in self.choices_made
))Audience Agency Design
Choice Design Principles
Make Choices Meaningful:
- Clear stakes: What's at risk?
- Visible consequences: Changes they can observe
- Emotional investment: Characters they care about
- No "right" answer: Multiple valid paths
Avoid Choice Paralysis:
- Limit to 2-4 options at decision points
- Provide adequate context (but not too much)
- Use time pressure sparingly and purposefully
- Signal importance level of choices
Voting and Collective Choice
class CollectiveDecision:
"""Aggregate audience input into story decisions"""
def __init__(self, voting_method='plurality'):
self.voting_method = voting_method
self.votes = {}
def collect_votes(self, options, timeout_seconds=30):
"""Gather votes from audience"""
# Methods: raise hands, mobile app, physical movement, sound
pass
def resolve(self):
"""Determine outcome based on voting method"""
methods = {
'plurality': self._plurality, # Most votes wins
'supermajority': self._supermajority, # Needs 2/3
'consensus': self._consensus, # Unanimous
'weighted': self._weighted, # Some votes count more
'random_delegate': self._delegate # One person decides
}
return methods[self.voting_method]()
def _plurality(self):
return max(self.votes.keys(), key=lambda x: self.votes[x])Individual vs Collective Agency
| Approach | Pros | Cons |
| Individual choices | Personal investment | Logistical complexity |
| Collective voting | Easy to manage | Minority feels unheard |
| Representative | Balance of both | Choosing representative |
| Parallel paths | Everyone gets agency | Requires more content |
Immersive Environment Design
Space as Narrative
TRADITIONAL STAGE IMMERSIVE SPACE
┌─────────────────┐ ┌─────────────────────────────┐
│ │ │ GARDEN │ LIBRARY │
│ STAGE │ │ (Past) │ (Memory) │
│ │ │ ◇ ↔ ◇ │
├─────────────────┤ ├────────────┼───────────────┤
│ AUDIENCE │ │ KITCHEN │ BEDROOM │
│ │ │ (Present) │ (Future) │
└─────────────────┘ │ ◇ ↔ ◇ │
└─────────────────────────────┘
◇ = Performance hotspot
↔ = Audience flow pathEnvironmental Storytelling Elements
class ImmersiveSpace:
"""Design an immersive theatrical environment"""
def __init__(self, venue):
self.venue = venue
self.zones = {}
self.artifacts = []
self.ambient_states = {}
def add_zone(self, zone):
"""Define a narrative zone"""
self.zones[zone.name] = zone
def design_discovery_path(self, story_beats):
"""Create environmental narrative arc"""
path = []
for beat in story_beats:
zone = self._select_zone_for_beat(beat)
artifacts = self._place_artifacts(beat, zone)
ambient = self._set_ambient_state(beat, zone)
path.append({
'beat': beat,
'zone': zone,
'artifacts': artifacts,
'ambient': ambient
})
return path
class NarrativeArtifact:
"""Object that tells story when discovered"""
def __init__(self, name, backstory, discovery_trigger):
self.name = name
self.backstory = backstory # What it reveals
self.discovery_trigger = discovery_trigger # How found
self.required_for_story = False
self.hidden_level = 0 # 0=obvious, 5=very hiddenSensory Design
| Sense | Storytelling Uses | Technical Considerations |
| Visual | Character, mood, focus | Lighting plots, scenic |
| Audio | Atmosphere, transition | Speakers, acoustic design |
| Smell | Memory, place, emotion | Scent machines, natural |
| Touch | Texture, temperature | Material selection |
| Taste | Ritual, communion | Food safety, allergies |
Live System Design
Real-Time Adaptation
class ShowController:
"""Manage live show based on audience behavior"""
def __init__(self, script, performers, systems):
self.script = script
self.performers = performers
self.systems = systems # Lights, sound, effects
self.current_beat = None
self.audience_state = AudienceState()
def update(self):
"""Called continuously during show"""
# Observe audience
self.audience_state.update(self._observe_audience())
# Check for triggers
triggers = self._check_triggers()
# Adapt if needed
for trigger in triggers:
self._handle_trigger(trigger)
# Cue performers
self._send_performer_cues()
def _check_triggers(self):
"""Detect conditions that require adaptation"""
triggers = []
# Audience engagement low
if self.audience_state.engagement < 0.3:
triggers.append(('low_engagement', 'intensify'))
# Audience moving to unexpected zone
if self._unexpected_movement():
triggers.append(('migration', 'redirect_or_adapt'))
# Time running over/under
pace = self._calculate_pace()
if pace < 0.8:
triggers.append(('slow_pace', 'compress'))
elif pace > 1.2:
triggers.append(('fast_pace', 'expand'))
return triggersPerformer Communication
class PerformerCueSystem:
"""Real-time communication with performers"""
def __init__(self):
self.performers = {}
self.cue_queue = []
def add_performer(self, name, device_type):
"""Register performer with their cue device"""
self.performers[name] = {
'device': device_type, # 'earpiece', 'wearable', 'visual'
'current_track': None,
'status': 'ready'
}
def send_cue(self, performer, cue_type, content, urgency='normal'):
"""Send cue to specific performer"""
cue = {
'performer': performer,
'type': cue_type, # 'go', 'hold', 'redirect', 'improv'
'content': content,
'urgency': urgency
}
self._transmit(cue)
def broadcast_state_change(self, new_state):
"""Inform all performers of story state change"""
for performer in self.performers:
self.send_cue(
performer,
'state_change',
new_state,
urgency='low'
)Documentation and Planning
Show Bible Structure
## [Show Title] Production Bible
### Concept
- Logline (one sentence)
- Themes
- Audience experience goals
### Narrative
- Story summary (non-branching core)
- Branch points and options
- Endings (and how reached)
- Character breakdowns
### Space
- Venue requirements
- Zone map
- Artifacts inventory
- Technical requirements
### Interactivity
- Choice points catalog
- Participation mechanics
- Edge cases and recovery
### Operations
- Audience journey map
- Performer tracks
- Stage management protocol
- Emergency proceduresRun Sheet Format
TIME | BEAT | ACTION | TRIGGERS
--------|----------------|----------------------|------------------
0:00 | GATHERING | Audience enters | N/A
0:15 | INTRO | Host welcome | All present
0:20 | CHOICE 1 | Vote on path | 2 min timer
0:22 | BRANCH A or B | Split audience | Vote result
... | ... | ... | ...
1:45 | CONVERGENCE | All paths meet | All groups arrive
2:00 | FINALE | Final choice | Timer
2:10 | END | House lights | ApplauseBest Practices
Designing for Failure
- Plan for empty rooms (no one chooses that path)
- Plan for crowded rooms (everyone chooses same path)
- Plan for confused audiences (unclear instructions)
- Plan for disruptive participants (graceful management)
- Plan for technical failures (degraded mode operation)
Rehearsal Process
- Paper prototype: Walk through on paper first
- Block rehearsal: Test spacing and movement
- Branch rehearsals: Practice each path separately
- Integration: Run full show with choices
- Audience tests: Invited audience for feedback
- Tech: Add all technical elements
- Previews: Public performances for refinement
References
references/choice-architecture.md- Designing meaningful decisionsreferences/immersive-case-studies.md- Notable productions analysisreferences/live-systems-tech.md- Technical implementation patterns
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

