go-cms-development

Guides cross-package Go CMS backend architecture changes with ownership and lifecycle rules.

Updated Jun 15, 2026
One-click install
npx skills add https://github.com/vernal96/go-cms --skill go-cms-development-vernal96
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: go-cms-development
Source: https://github.com/vernal96/go-cms/tree/main/.codex/skills/go-cms-development
Command: npx skills add https://github.com/vernal96/go-cms --skill go-cms-development-vernal96

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Cross-package backend changes in a Go CMS often blur ownership boundaries, duplicate registration glue, and break persistence direction. This Skill provides a disciplined workflow for implementing reusable architecture changes without over-abstracting or reconstructing the whole repository. ## Core Features & Use Cases - Ownership Classification: Assigns behavior to kernel, module, connector/adapter, or project/internal owners and scopes state to application, profile, site, module, or request lifetime. - Declarative Project Rule: Moves generic registration, validation, ordering, and lifecycle mechanics into reusable owners so project code holds only unique identity and bindings. - Persistence Direction Enforcement: Preserves the flow from project selection through connector, module adapter, and repository to service/runtime. - Use Case: When adding a new module with routes, migrations, and seeds, use this Skill to decide which code belongs in the module versus reusable registries, then run focused tests before broad backend checks. ## Quick Start Use the go-cms-development skill to plan and implement a new backend module with routes, migrations, and seeds following the ownership and lifecycle rules.

Frequently Asked Questions about go-cms-development

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure cross-package backend changes in a Go CMS?▼

Start by inspecting the declaration entry point, the reusable registry or manager consuming it, and one nearby working pattern. Classify each behavior by owner (kernel, module, connector, or project) before editing, and expand to other packages only when a real dependency requires it.

When should code live in the kernel versus a module?▼

Kernel owns generic contracts, managers, registries, factories, and lifecycle mechanics, while modules own domain behavior, services, repositories, and module-specific extension mechanics. If adding a similar item tomorrow would copy generic registration glue, that glue belongs in the reusable owner.

Should I use this workflow for small local bug fixes?▼

No. The Skill explicitly excludes isolated local fixes where the affected package is sufficient. It targets cross-package or cross-cutting work involving architecture, registries, routes, migrations, seeds, caches, or filesystems.

How do I keep persistence direction correct in a modular Go backend?▼

Follow the flow: project selection to connector to module adapter to repository contract to service/runtime. Connectors stay low-level technology clients, repositories know domain entities, and project code selects factories rather than manually constructing services.

What testing strategy fits cross-cutting backend changes?▼

Add focused tests for changed contracts and invariants, run them while iterating, and use broad backend checks only near completion for cross-package work. Keep changes incremental and avoid unrelated cleanup.