Skip to content

Onboard Your System

This is the second setup step in Get Started with AI, after you connect Claude and install the plugin.

Onboarding takes a new or empty instance to a fully populated security-documentation foundation: the system information, capabilities, components, control implementations, implemented requirements, implementation narratives, and parameter values your SSP or Security Decision Record renders from. One guided flow owns the whole journey, and you do not need to know the asset model to run it.

Start it in Claude Code with the connector and plugin configured (see Connect and Install):

/grcitsm-analyst:ssp-onboard

/grcitsm-analyst:sdr-onboard is the same flow under its FedRAMP 20x name -- both artifacts render from the same foundation. You can also ask -- "where do I start with our SSP?" -- and the plugin detects your instance's state and starts at the right point.

What to have ready

  • Any written material you have. Policies and procedures are the highest-yield inputs; meeting transcripts, an old SSP in any format, and even rough notes all extract. Drop them in the working folder when the flow asks -- overlap and contradictions between files are fine, the reconciliation surfaces them for you to resolve. Architecture diagrams as images are not read; describe the boundary in text or cover it in the interview.
  • The right people. The system-framing interview (boundary, network architecture, data flow) goes best with whoever knows the architecture; per-capability interviews (identity, logging, incident response, ...) go best with whoever owns that operational area. Sessions checkpoint and resume, so nobody has to be in the room at once.
  • Your baseline choices. Which FedRAMP or CMMC baselines the system certifies against -- the flow presents your instance's actual options to pick from.

How it runs

Stage What happens What it writes
1. State detection Verifies the connection, resolves which system you are onboarding, and probes what already exists Nothing
2. Foundation bootstrap If the system information is empty: three facts -- System Name, short name, baselines -- and the framework skeleton is created, with a placeholder for every control in scope One small approved write
3. Gather Documents are extracted and cited line-by-line; interviews structure your plain answers into documentation-grade narrative. Use either or both -- most systems do both Nothing -- everything lands in a local working copy
4. Gap loop After each pass, a coverage report names what is well covered and what is missing, per capability. Add more documents, take a targeted interview, or accept the gaps as documented Nothing
5. Review and approve The complete change plan renders in plain language -- every proposed record, old and new values, and the source it came from. Approve everything, approve specific rows, or describe edits in plain English Nothing until you approve
6. One bulk write The approved plan applies to your instance as a single disciplined bulk operation, followed by a verification pass that confirms what landed Everything, once

Everything is assembled locally first

Between the bootstrap and your final approval, nothing touches your instance. The whole system definition is built and refined as one local working copy -- reviewed for accuracy, coherence, and coverage against your baselines as a whole, rather than written piecemeal. That is deliberate: cross-references stay consistent, duplicates get merged before they exist as records, and you approve the complete picture once instead of approving fragments dozens of times.

Plan for more than one sitting

A full system definition is a real body of work -- expect several sessions, not one. Progress is checkpointed continuously: stop anytime, and the flow resumes where it left off without re-asking what it already captured. The final bulk write can also take a while on a large system (it is creating or updating hundreds of records, followed by a verification pass); start it when you do not need the answer in the next few minutes.


Keep it current (refresh and updates)

After onboarding, your instance is the source of truth -- people update records in the UI, AI-assisted changes land through approvals, and the documentation renders from live state. Updates are incremental; you never re-run onboarding over a populated system. Match the change to the path:

What changed What to do
A narrative is wrong, a parameter value moved Ask in chat -- small fixes are made as direct reviewed edits, each shown to you for approval before it lands
A policy or procedure was revised, or new documents exist /grcitsm-analyst:ssp-ingest -- extracts the documents, diffs them against current state, and proposes only the changes, with row-level approval
A capability area needs to be extended or filled in /grcitsm-analyst:ssp-interview --additive -- reads what exists and asks only about what is missing
New components, a re-architecture, a bulk migration The flow captures current state into a working copy first, applies your changes against it, and guards the write-back against anything that changed on the instance in the meantime
You want the current SSP/SDR document /grcitsm-analyst:ssp-generate -- renders it read-only from live state, anytime

Two habits keep the foundation trustworthy:

  • Ingest documents when they change, not before an audit. A revised access-control policy is a five-minute ingest the week it ships; twelve months of drift is an onboarding-sized effort.
  • Render after meaningful changes. /grcitsm-analyst:ssp-generate also produces a gap report -- running it after a change cycle shows you what the documentation now says and what it still lacks.

Same rules, whatever the size

Every path above ends in the same discipline: proposed changes are shown before they execute, writes carry your identity, and the record trail shows what changed and why. The paths differ only in how much machinery stands between you and the write -- a one-line fix does not need a working copy, and a re-architecture should not be applied line by line.


Next: Run Your System