Philosophy

Work matters when it helps real people achieve their goals.

The Problem We're Solving

Fred Brooks identified the core challenge of software development decades ago:

"The hardest part of software development is deciding what to build."

The industry's response has been an ever-growing stack of project management tools, methodologies, and metrics. But these tools optimise for the wrong thing. They track team activity instead of user outcomes.

Teams can hit every metric and still ship products that don't help anyone. The work is "done" but the actor's story has no satisfying ending.

Your Actors, Not Your Objectives

The gravitational pull toward self-centred work is powerful. Backlogs fill with technical tasks. Roadmaps become feature lists. Standups become status reports about what we're doing rather than who we're helping.

Epilogue Tracker exists to counter this pull. It keeps the focus on:

• Who the real people are (Actors)
• What they're trying to accomplish (Goals)
• How they interact with your system (Interactions)
• What success looks like for them (Outcomes)

Everything else is secondary. Implementation details, technical architecture, work coordination: these may be necessary, but they're not the point. The point is helping real people achieve their goals.

The Screenplay Pattern

Epilogue Tracker uses the Screenplay Pattern as its organising structure. Like a screenplay for a film, it describes:

• Actors: The real people who will use your system
• Goals: What each actor is trying to achieve
• Interactions: How actors engage with the system to achieve goals
• Journeys: Sequences of interactions that tell a complete story

This isn't a new project management methodology. It's a model of intent. A living document that answers "what are we building and why?" at any moment.

Challenge Every Task

Before any work begins, ask:

1. Which real person benefits from this?
2. What goal of theirs does it support?
3. How does this interaction help them achieve it?

If you can't answer these questions, the work may not be justified. Finding the actor's need isn't extra overhead. It's the actual job of product development.

Reframing Technical Work

Technical work isn't exempt from this challenge.

Task: "Add database indexes"

This seems like pure technical work. But ask the questions:

• Which actor? → Customer
• What goal? → Browse products without delays
• How does this help? → Faster queries mean faster page loads

Now the work has purpose. It's not "add indexes." It's "help customers browse quickly."

Where This Is Heading

The Task Layer Disappears

Here's what most people aren't ready to hear: the entire task layer (stories, estimates, Kanban boards) may become irrelevant.

That infrastructure exists to coordinate human implementation effort. But what happens when GenAI can go directly from intent to working software?

Today:     Intent → Tasks → Developers → Product
Tomorrow:  Intent → GenAI → Product

If you have a well-modelled screenplay (actors, goals, interactions) and a technical foundation for GenAI to work within, the implementation becomes a function call. The tasks and stories were scaffolding for human coordination. Remove the human implementation bottleneck, remove the scaffolding.

What remains essential:

1. Knowing what to build: The screenplay. This is the hard part.
2. Defining the boundaries: The technical envelope GenAI works within.
3. Validating the output: Does it actually help the actor achieve their goal?

Epilogue Tracker becomes the specification layer. Not "requirements that get translated into tasks that get assigned to developers." Just requirements that get translated into product.

Developers as Envelope Builders

This doesn't eliminate developers. It elevates them.

Business Intent → GenAI → Product
                    ↑
          Technical Envelope
            (Developers)

The technical envelope (architecture patterns, security boundaries, deployment infrastructure, performance constraints, integration standards) requires deep engineering expertise to craft. This is foundational work, not transactional work.

Developers invest in the envelope, and that investment pays dividends across every intent-to-production cycle. They're no longer in the critical path for every feature. They engage when:

• The envelope needs to expand (new capability required)
• The envelope has a flaw (security issue, scaling limit)
• The business wants to enter new technical territory

Their work becomes higher-leverage. Less "implement this button" and more "make the system capable of entirely new classes of interaction."

Determinism and Non-Determinism

This future requires clear boundaries between deterministic and non-deterministic layers:

Layer	Behaviour
Screenplay Model	Deterministic: actors, goals, interactions, states
AI Interpretation	Non-deterministic: inference, classification, synthesis
Technical Envelope	Deterministic: architecture, constraints, boundaries
Generated Implementation	Non-deterministic within deterministic bounds

The screenplay is the stable specification. The envelope is the stable foundation. GenAI fills the creative space between them, but always within defined boundaries.

The Epilogue

In storytelling, the epilogue shows how things turned out for the characters. Did they achieve what they wanted?

In Epilogue Tracker, when the actor achieves their goal, the story has a satisfying ending. That's the true definition of "done." Not tasks completed, but real people helped.

Next Steps

• Getting Started: Install and use Epilogue Tracker
• Breaking Down Work: Apply this philosophy in practice
• Actors: Model the real people you're helping