Dear friends,
When programs grow out of a small prototype, the question of modularization inevitably arises.
At the beginning, everything is manageable: a single file, a clear flow, fast changes. As functionality increases, the classic question emerges:
How should I modularize correctly – and what is the best approach today?
Many of us grew up with the classical approach: clean separation, many PRGs, clear responsibilities. For a long time, this was the gold standard – and in many projects, it still is.
In practice, however, a recurring problem becomes apparent: as modularization increases, not only does structure grow, but often context is lost as well – especially during debugging and in complex execution chains.
At the same time, the reality of development has changed significantly. AI support, mixed stacks (PRG, PHP, JS, HTML), rapid iteration cycles, and debugging in live systems play a very different role today than they did 10 or 20 years ago.
Out of exactly these observations, I started to explore a different approach: Harbourino.
One important clarification: Harbourino is not an “everything-in-one-file” chaos approach.
During development, the code remains modular, well-structured, and IDE-friendly, split across many individual code files. The decisive difference lies in delivery and debugging:
The production code is automatically patched into a context-rich single file.
Compact Summary
The Harbourino approach shows why it can be superior to the classical approach today – particularly with regard to debugging, context preservation, and AI-assisted development.
Classical approach
many PRGs, clean functional separation IDE-friendly, familiar, small files but: debugging across many files, loss of context, difficult for AI, fragmented execution logic
Harbourino approach Development: logically separated code files (PRGs, PHP, JS, HTML) → high clarity, IDE support, clean domain separation
Delivery / runtime: automatically patched single-file code → full context, linear debugging, unambiguous logs
What really matters
Debugging is objectively optimal in a single file:
the complete execution flow is visible
no file hopping
clear line numbers and breadcrumbs
AI benefits maximally:
full context in a single prompt
precise block-level patches instead of global assumptions
In mixed projects (PRG / PHP / JS / HTML):
syntax highlighting remains intact at the block level
consistent navigation despite multiple languages
Conclusion & Discussion
The Harbourino approach combines the best of both worlds:
many files for development
one file for debugging, delivery, and AI
This is not a compromise and not a weakening of classical principles, but an evolution under modern conditions: AI, mixed technologies, fast iterations, and production-close debugging.
I am especially interested in practical experience: How do developers who are used to classical modularization react to this approach? Where do you see similar challenges – and what solutions have you found?
Best regards, Otto