gstack is rigorous once evidence exists. Before code, customer discovery skills and a reliable memory layer are needed to produce and preserve the proof it expects.
All articles
Technical depth, architectural thinking, and hard-won lessons from building systems. Published as local MDX files.
A Hermes personal shopper exposes a durable architecture boundary: the agent runtime may produce decisions, but canonical product state needs a life outside it.
Agent memory is a scoped service layer, not runtime state owned by an agent instance.
How to test whether a layered agentic workflow preserves context, responsibility, verification, and recovery for a solo developer.
Why an agentic factory is an architecture of responsibility, evidence, and boundaries—not a stack of tools or a more powerful coding agent.
Why tenant scope is an authority boundary, and how RequestContext makes multi-tenant trust explicit and enforceable.
AI makes software cheaper to explore and build, but not equally cheap to understand, secure, review, and own.
Why producing working code faster with AI raises the stakes on architectural quality, and why passing tests is not the same as having sound boundaries.
Why OpenSpec belongs in a different category than knowledge tools—and why planning before execution is the actual constraint it addresses.
Why building a real multi-tenant SaaS stops being a feature problem and becomes a problem of trust boundaries, guarantees, and responsibility placement.
Why the biggest gain in AI-assisted development comes from durable local knowledge and disciplined workflow structure, not from keeping every external tool always active.
Why I kept this blog's publishing system repo-native, with explicit state and handoff boundaries, instead of reaching for a CMS too early.
Why AI-assisted development breaks down when useful reasoning disappears between sessions, and why durable project context matters more than clever prompts.
Why planning is less about agent autonomy and more about making AI-assisted work inspectable before it becomes expensive.
Why server-first Next.js development is less about state management libraries and more about putting authority in the right place.
Why AI does not break product coherence by itself, but makes local UI deviation cheap enough that drift appears faster than many teams can review it.
Why agent tools are control surfaces for safe, reviewable loops—not just callable functions.