Claude Code for Enterprise (AI-CC500)

This two-day course teaches engineering teams how to use Claude Code to drive a real ticket -- from acquisition, through investigation and remediation, to a deploy-ready fix that holds up under enterprise governance and core-team review.

Most engineering teams already have a ticketing system, an escalation ladder, a core team that owns production code, and a queue of tickets that take more time to investigate than to fix. Claude Code shortens the investigation, drafts the change, generates the tests, and packages the result for review -- without bypassing the people who own the codebase. This course follows that lifecycle end-to-end. Participants bring real tickets from their own queue and work them through Claude Code with guidance: pulling ticket and log context through MCP, producing a root-cause plan, drafting code, generating tests, and packaging a reviewable change. Throughout, the course emphasizes an "augment, not replace" posture -- humans stay in the loop at every gate, and DBAs and core-team reviewers retain the controls they already have. By the end, each participant has a working skill, an MCP starter, and a fix package they could hand to their own core team.

1. Claude Code Foundations
   1. The terminal-native interaction model and project context
   2. Models and the speed/quality dial (Opus, Sonnet, Haiku; fast vs. deep-thinking)
   3. Slash commands, plan mode, and sub-agents
   4. The augment-not-replace posture and where humans stay in the loop
2. Acquiring Tickets
   1. Connecting Claude Code to your ticketing system through MCP (ServiceNow, Azure DevOps, Jira, custom)
   2. Pulling ticket details, customer comments, related tickets, and prior resolutions into context
   3. Reading screenshots, scanned attachments, and error images with vision
   4. Filtering and queue triage patterns
3. Reviewing Tickets and Producing a Remediation Plan
   1. Long-context investigation across application logs, audit logs, and source code
   2. Cross-referencing log entries against the codebase to identify root cause
   3. Plan mode for showing the proposed approach before any expensive work runs
   4. Sub-agents for parallel hypothesis exploration
   5. Authoring a reusable triage skill so every ticket starts the same way
4. Generating Code
   1. Repo-aware code drafting against the conventions your core team already enforces
   2. SQL generation and tuning: reading query stats, suggesting indexes, refactoring slow procedures
   3. Stored procedure documentation, schema migration scripts, and rollback drafting
   4. Drawing the line between changes the core team will accept and changes they will push back on
5. Testing and Packaging the Fix for Review
   1. Generating a reproducible issue summary and a failing test that captures the bug
   2. Synthetic test data that respects PII and matches production shape
   3. Running unit and integration tests through Claude Code's code execution
   4. Packaging the diff, the test, and the change description as a reviewable unit
   5. Branch and pull-request authoring conventions for hand-off to the core team
6. Reviewing Pull Requests
   1. Pre-submission self-review: Claude reads your own diff before you push to catch obvious issues
   2. Reviewing a teammate's PR end-to-end and producing a review summary with risk flags
   3. Drafting concrete inline review comments tied to specific lines
   4. Cross-referencing changes against project conventions, prior incidents, and impacted code paths
7. Responding to CI/CD Failures After Submission
   1. Connecting Claude Code to your CI/CD system through MCP (GitHub Actions, Azure Pipelines, Jenkins, GitLab, etc.)
   2. Pulling failed build logs, test failures, type errors, and integration stack traces into context
   3. Diagnosing the failure against the proposed change and proposing a targeted follow-up
   4. Pushing fix commits and re-running the pipeline without leaving the workflow
   5. Tying CI feedback back to the original ticket so the audit trail stays intact
8. Bug Fix Patterns
   1. Reproducing intermittent and flaky bugs deterministically
   2. Bisecting to identify the change that introduced a regression
   3. Hotfix workflows under time pressure, with rollback drafted alongside the fix
   4. Backporting patches across release branches and long-lived support lines
9. Governance, Cost, and the Team Toolkit
   1. MCP architecture as the chokepoint: vendor MCPs vs. custom MCPs, read-only by construction, DBA-owned access
   2. What stays local, what goes to Anthropic, and what is never used for training
   3. SOC 2 / HIPAA posture, enterprise plan controls, and audit trail design
   4. Token economics, model selection, and predictable usage reporting
   5. Skills as durable team infrastructure: anatomy, deterministic patterns, and reuse
   6. Building a standardized triage library: codifying your senior engineers' best workflows as shared skills the whole team starts from
   7. A shared .claude/skills/ repository so prompts, patterns, and triage flows become enterprise defaults rather than tribal knowledge

Each student receives a comprehensive set of materials, including course notes and all class examples.