CascadingWave
The methodology the software is produced by.
This is the layer underneath everything else on this site. If you want to know how the work is actually structured, it’s here.
The machine
One human directs a team of specialized agents. The agents do the implementation work. The human makes every judgment call that matters.
Design, build, check.
The three phases run in order, with feedback loops. Each one feeds the next, and what the next phase learns feeds back.
- Design.
- Work becomes a build-ready package. A business capability model, then the process spine, then module specifications, then the detailed processes that are the source of truth — with the interface designed per touchpoint and reviewed on screen before anything is signed off.
- For enhancement work against an existing product, this phase is skipped. Already-vetted items go straight to the build.
- Build.
- Both paths converge here. Driven by one human, punctuated by hard checkpoints. The build never runs unattended from start to merge.
- Check.
- Tests across multiple independent layers, then a real-user walkthrough of the running application, then a compliance and architecture pass, then delivery.
The difference is speed. A fraction of the time traditional development takes. Weeks, not quarters.
Four principles.
- Holistic.
- The whole system is considered together, not assembled from parts optimized separately. A change is evaluated against everything it touches, not just the piece being changed.
- Context continuity.
- Knowledge carries forward. Nothing restarts from zero — every decision, standard and pattern established on earlier work remains available to later work.
- Accept, reject, refine.
- Every artifact is reviewed and dispositioned. Nothing passes by default and nothing accumulates unreviewed. Accepted, rejected, or sent back for refinement — a daily habit, not a gate at the end of a phase.
- Continuous adaptation.
- The methodology adjusts as the work reveals what it actually needs. What is learned on one build changes how the next one runs.
Everything is built against standards.
Not conventions someone remembers. Documented standards the system applies on every build.
- Rendering-assertion testing. End-to-end tests assert the value is visible on screen, not that a request succeeded.
- One seed per environment. No re-seeding mid-session, no runtime seed toggles.
- Server-side pagination on large grids. Never load full sets to the browser.
- Bulk writes are batched, never row-by-row.
- Test at volume, not just correctness. Correctness with one record hides failure at ten thousand.
- Bug versus defect. Found during the build, fixed in the build. Found after completion, tracked as new work.
- Verified one-command environment reset, checked every session.
- Baseline preservation. The existing passing tests run before any change and are never edited to pass.
- Three test layers, every session. Backend, interface, and end-to-end. None optional.
- Test self-correction. A failing test is diagnosed as a real defect or a bad test before anything escalates.
- AI features behind a provider-agnostic seam, testable without the provider.
- Four environments, not five. Local, validation, acceptance, production. No separate development environment.
- Automated accessibility checking as a build gate, failing on new violations — not a manual audit bolted on afterwards.
Note for real-time and embedded work: the test-layer definitions assume software with an interface. Embedded work relies on hardware-in-the-loop testing instead. The floor — multiple independent test layers, none skipped — still applies.