AI Enablement Engagement

Session 1 — Discovery & Current-State Assessment

Phase: 1 — Assessment & Strategy
Target Week: Week 1 — next session, target week of June 8, 2026
Duration: 2 hours
Format: Remote working session — live build + governance decisions
Audience: Ronnie (lead / architect), Steve (Nubitz — facilitating and driving Claude Code), Donnell (sponsor, optional)

Pilot selected: the Citizen Developer Portal — a new build. Most current-state discovery (stack, governance culture, security, CI/CD, current AI tooling) was already captured in the kickoff, so this working session pivots from interview to action: vet the feature set, scaffold the product's shell live with Claude Code, and decide where governance is inserted as the code is written.

Working Focus — Build the Shell & Wire In Governance

Two threads run together: stand up a thin end-to-end slice of the Citizen Developer Portal using Claude Code (Max), and at each step of the build decide — with Ronnie — what gates, checks, and guidance to insert. The point is to make governance a property of the build process, agreed live, not a document written afterward.

Objective

Turn the selected pilot from concept into a running, governed skeleton. Agree what the Citizen Developer Portal is and what we build first, stand up its shell with AI from the first commit, and decide — concretely, with the lead architect — where governance lives in the day-to-day build process, so the team can replicate the pattern on every product that follows.

The Pilot Product — Citizen Developer Portal

A governed "front door" for non-IT citizen developers: they propose projects, IT routes and approves them, and approved projects get a champion, training, and sanctioned access to build in Mendix (LCAP). The portal tracks who is building what and what access they need — it does not host the development itself.

Proposed feature set (to vet and prioritize in-session):

  • Identity & roles — Google Directory (GCP) SSO, on-network; roles for Citizen Developer, Champion, IT Reviewer/Admin. No forms auth.
  • Project proposal intake — a form capturing the idea, who it helps, and what data/systems it touches.
  • Review & triage workflow — IT routes each proposal: Build in Mendix, Buy, Needs info, or Decline (with reason).
  • Proposal pipeline / status board — visible status from submitted to live.
  • Champion assignment — pair an approved proposal with a pro-dev mentor.
  • Training resource library — curated learning content, owned by the training team.
  • Q&A forum — searchable help that accumulates into a knowledge base.
  • Access request tracking — capture and route the access a project needs (tracks, does not auto-provision).
  • API / component catalog — read-only catalog of governed components citizen devs can request to use in Mendix.
  • Announcements & calendar — office hours, training sessions, champion availability.

First vertical slice for the shell: Identity + Proposal Intake + Status Board — enough to stand up the React + MUI front end, the .NET Core API, SQL + EF, and the first auth path, and to start attaching governance to a real build.

Governance — Where It Gets Inserted

Governance is decided as a property of the build pipeline, stage by stage — across AI context & guardrails, local dev, agentic dev, PR creation & review, merge/commit, CI/CD, and deployment. The full insertion-point menu, with recommendations and rationale, lives in the detailed agenda. Recommended starter set to stand up during this session:

  • CLAUDE.md encoding Turner standards — written before any code, so the agent follows house rules by default (the cheapest, highest-leverage guardrail).
  • Pre-commit hooks — format, lint, and secret scan before a commit is even created.
  • Plan-first + diff-summary discipline — the agent plans before it edits and summarizes its own diffs, flagging risky changes. The direct answer to "people stopped reading the diff."
  • PR template + branch protection + required checks — formalizes the review Turner already does (can't approve your own PR, ≥1 reviewer).
  • One custom skill — start with the PBI / work-item writer; the recommended priority list (PBI writer → back-end review → feature-slice scaffolder) is in the detailed agenda.

Outcomes

  • A vetted, prioritized feature list and an agreed first vertical slice
  • A running shell of the Citizen Developer Portal, scaffolded live with Claude Code
  • A set of governance decisions — what is inserted where — with several stood up live in the repo
  • Named sister product confirmed as the reference for Session 3 hands-on exercises
  • A backlog of the next slices and the governance items deferred to Sessions 3–6

Inputs Required from Turner

  • Ronnie present with decision authority; named second developer if one will attend consistently
  • Claude licenses provisioned (Ronnie on Max; team on Pro)
  • Azure DevOps project location for the new repo, with rights to create it
  • Google SSO (GCP) app-registration path for the new app
  • The sister Turner product (existing React + .NET app) to use as the conventions reference
  • Any developer guidelines or security policies that should shape CLAUDE.md

Deliverable Contribution

Feeds the AI Development Strategy Document (Phase 1 deliverable) — concrete feature scope, the governance insertion-point decisions, and the configuration assets (CLAUDE.md, hooks, PR template, first skill) that become the worked example threaded through the rest of the engagement.