I came to this way of working backwards from how it is usually taught:
not from frameworks down to the foundations, but from the foundations
upwards. Once you understand what actually happens between a statement
and the processor, a shallow answer stops satisfying, and it
keeps climbing, floor after floor, until it stops at
documentation and operations. Bell Labs are the model for me:
Unix, Plan 9 and, in a direct line, Go were born where one
person carried the theory and the operations at once.
The scientific method is not rhetoric here. Measurement is what
separates a supposition from a result, and documentation with
tests is what separates code from an artefact. That is why a
processor core is verified against a reference model, a protocol
against the Linux kernel, and every dependency has to defend its
place with a number, not a fashion.
The path there also ran through operations: years of designing and
running servers and networks, supporting users and delivering
infrastructure. They taught me that documentation and measurement
are not bureaucracy but the way to keep something running. The
lowest floor this path led me to is silicon: work on processor
cores is still private research, which is why this site shows
nothing more of it.
Outside computers, I am at my best when something begins: a project, a
tool, a deployment. Not the meetings about them, but the part where a
question mark becomes a design and a design becomes a running system.
If that is exactly what you need, we understand each other.
For daily work I use GoLand; for pair programming with open models, ZCode.
A larger whole does not mean a larger team. I split the work
into roles that check each other: the architect writes the
design, the coder carries it out, the reviewer reads it with
someone else's eyes, the verifier measures it, and anything
that fails a gate is never integrated. Parallel branches each
run in their own working copy; the open models beside me are
craftsmen and the decisions stay mine.
All of it runs on an ecosystem of my own: Gitea with its own
CI, JSbox as the web toolchain, Volumen as the publishing
engine, Perl for the operational scripts. The tools I develop
for myself are also the ones I publish: operations and open
source are the same work.