What Philosophy Planner Simple Actually Is
Philosophy Planner Simple is a planning framework built around tracking decisions through structured reasoning rather than just listing tasks. You map out the "why" before the "what." It's not a notebook app or a Gantt chart generator. It's a way of organizing your thinking so you don't end up spending three months on something that was never a priority in the first place. The core idea is straightforward: every plan gets split into philosophy, constraints, options, and actions. Most people skip the first two and jump straight to actions. That's why half their projects fizzle out at month three.
Getting Started With Philosophy Planner Simple
Download the template or scaffold from the main repository. The open source version lives at github.com/philosophyplanner/simple. Grab it, clone it, and install the dependencies. If you're on Python 3.10 or later, pip install will handle the rest in about ten seconds. The documentation is sparse but functional. Once installed, the interface asks for your planning objective first. Not your tasks. Your objective. This trips people up. Write one sentence. "Ship the beta by June." Not "Build features." One sentence, nothing more. From there, the planner generates a philosophy branch. This is where you state the reasoning behind the objective. Not the justification. The reasoning. There's a difference. Justification argues why you should do it. Reasoning states what conditions must hold true for the plan to succeed. I learned this the hard way when I spent two weeks building a feature that satisfied the justification but violated the actual reasoning behind the project. My workaround was to add a simple constraint check before every sprint review: "Does this decision hold under the stated reasoning, or just under the justification?" It took about five minutes to set up and saved me from another month of drift.
How The Planning Cycle Actually Works
The cycle runs in four passes. Philosophy, constraints, options, actions. You don't move forward until each pass has at least three entries. Not one. Three. This forces you to consider alternatives instead of latching onto the first idea that came to mind. Philosophy pass: write your reasoning statements. Keep them factual, not aspirational. "Users need faster export times" is reasoning. "We should become the fastest export tool" is a goal, not reasoning. Getting this wrong early makes the rest of the cycle noisy and unfocused. Constraints pass: list everything that limits you. Budget, timeline, staffing, technical debt, legal requirements, whatever applies. Be specific. "Budget" is vague. "$40,000 run rate with zero discretionary spend after March" is a constraint you can actually plan against.
Get the Full Details
Options pass: for each constraint, note the workarounds or alternatives. This is where most planners fail because they treat constraints as walls instead of boundaries. A constraint doesn't end a plan. It defines where the plan can move. When I was planning a migration last year, I initially treated the compliance deadline as a hard stop and considered dropping the whole project. The options pass made me map three alternative paths that still met the deadline without full compliance. One of them shipped two weeks ahead of schedule. Actions pass: only here do you write tasks. And even then, each action must trace back to at least one option, which traces back to at least one constraint, which traces back to the reasoning. If you can't make that chain, the action isn't ready.
Common Mistakes People Make
The biggest error is treating the framework as linear. It isn't. You'll loop back. New information will invalidate a constraint. An option will fail and force you back to the constraints pass. That's normal. The planner is designed for revision, not a one-shot walkthrough. Another mistake is filling out the template mechanically. Writing entries just to satisfy the three-entry minimum doesn't help anyone. I've seen teams generate twelve options that were all the same thing in different words. That's not planning. That's decoration. The software itself has a quirk worth noting: the export function defaults to JSON unless you change the output settings. I wasted an afternoon debugging why my downstream tools couldn't read the plan until I realized I never switched the format flag. Add --format yaml to your export command next time.
When This Approach Falls Apart
Philosophy Planner Simple doesn't scale well beyond roughly fifty active decisions. After that, the tracking overhead becomes heavier than the benefit. The branching model starts creating too many cross-references to maintain manually. If you're running a program with twenty different initiatives, use this for each initiative separately, not for the whole program. A program-level view needs something more aggregated. It also requires honest self-assessment. The framework won't catch you lying to yourself about constraints. If you claim your budget is "$10,000" when it's really "$3,000 with hope," the planner will build a house on that number and collapse when the reality shows up. No tool fixes that. Only discipline does. For teams that need heavy collaboration, the vanilla version lacks real-time sync. I ended up layering it on top of a shared drive with version naming conventions, which works but adds friction. If you need live co-authoring, there's a paid extension that handles conflict resolution, but it's not cheap.
The bottom line is that Philosophy Planner Simple is useful when decisions matter more than speed. It slows you down upfront so you don't waste time later. If you're in constant fire-fighting mode, it won't help. You'd be better off with something lighter that just tracks execution without the reasoning overhead.
