Coc Reference

What is COC?

COC is a five-layer architecture that provides AI coding assistants with the organizational context, guardrails, and operating procedures they need to function as disciplined engineering partners. It applies the CARE framework's Human-on-the-Loop philosophy to software development.

COC is a new term introduced in the thesis paper. It names an architecture that the Kailash ecosystem has implemented. The principles are not new; the systematic five-layer organization is.

The Problem: Vibe Coding's Three Fault Lines

The root cause is not model capability. It is the absence of institutional knowledge surrounding the model.

The Value Hierarchy Inversion

Vibe Coding:  Better Model → Better Code → Competitive Advantage
COC Reality:  Better Context → Better Output → Competitive Advantage
              (specific to you)  (any model)    (defensible)

The Five-Layer Architecture

+--------------------------------------------------+
|          Layer 5: LEARNING                        |
|    Observation → Instinct → Evolution             |
+--------------------------------------------------+
|          Layer 4: INSTRUCTIONS                    |
|    Structured methodology with approval gates     |
+--------------------------------------------------+
|          Layer 3: GUARDRAILS                      |
|    Deterministic enforcement, not suggestions     |
+--------------------------------------------------+
|          Layer 2: CONTEXT                         |
|    Your living institutional handbook             |
+--------------------------------------------------+
|          Layer 1: INTENT                          |
|    Specialized agents, not generalist AI          |
+--------------------------------------------------+

Layer 1: Intent - The Role

• Solves: Generalist AI producing generalist output
• Principle: Route tasks to specialized expert agents
• Implementation: 30 agent definitions, 7 development phases
• Key specialists: deep-analyst, security-reviewer, framework specialists
• What it encodes: Your organizational structure

Layer 2: Context - The Library

• Solves: AI defaulting to internet conventions
• Principle: Replace stale training data with your living institutional handbook
• Implementation: Progressive disclosure (CLAUDE.md → SKILL.md → Topic files → Full docs)
• Two principles: Framework-First (never code from scratch) + Single Source of Truth
• Key distinction: Context engineering (persists across sessions) vs prompt engineering (single interaction)
• What it encodes: Your institutional knowledge

Layer 3: Guardrails - The Supervisor

• Solves: Probabilistic compliance ("most of the time" is not enough)
• Principle: Deterministic enforcement, not probabilistic compliance
• Implementation: 9 rule files (soft) + 9 hook scripts (hard)
• Key mechanism: Anti-amnesia hook (user-prompt-rules-reminder.js) - fires every message, survives context compression
• Defense in depth: Critical rules have 5-8 independent enforcement layers
• What it encodes: Your risk tolerance

Layer 4: Instructions - The Operating Procedures

• Solves: No procedural discipline (AI writes code before confirming approach)
• Principle: Structured methodology with approval gates
• Implementation: 7-phase workflow, 4 quality gates, 20 slash commands (13 framework + 7 workspace phase)
• Key features: Evidence-based completion (file-and-line proof), mandatory delegation (security review before every commit)
• What it encodes: Your process maturity

Layer 5: Learning - The Performance Review

• Solves: Stateless sessions (every session starts from zero)
• Principle: Observe, capture, evolve. Knowledge compounds.
• Implementation: Observation-Instinct-Evolution pipeline
  • Observation: JSONL logs of tool usage, patterns, errors
  • Instinct: Pattern analysis (confidence = frequency 40% + success 30% + recency 20% + consistency 10%)
  • Evolution: Suggest artifacts (Skills ≥0.7, Commands ≥0.6, Agents ≥0.8) - all require human approval
• What it encodes: Everything above, compounding over time

CARE → COC Mapping

The Human-on-the-Loop Developer

The developer's unique contribution is not writing code but defining and maintaining the institutional context:

• Layer 1: Articulate domain structure
• Layer 2: Document institutional knowledge
• Layer 3: Identify non-negotiable rules
• Layer 4: Formalize methodology
• Layer 5: Extract patterns from experience

Bainbridge's Irony (1983): The more automated a system becomes, the more critical it is that human operators maintain deep understanding. Every COC layer deepens the developer's expertise.

Honest Limitations

• Novel architecture decisions (no established pattern to follow)
• Distributed systems complexity (emergent problems beyond local guardrails)
• Team dynamics and culture (organizational, not technical)
• Model-specific limitations (reduced, not eliminated)
• Legacy codebases (fewer frameworks to compose with)

Quick Reference

COC = Cognitive Orchestration for Codegen
  5 Layers: Intent → Context → Guardrails → Instructions → Learning
  3 Fault Lines: Amnesia, Convention Drift, Security Blindness
  1 Insight: Institutional knowledge > Model capability

The Kailash COC Implementation:
  30 agents, 28 skills, 9 rules, 9 hooks, 20 commands
  Reference: github.com/Integrum-Global/kailash-coc-claude-py

For Detailed Information

Read these source documents:

• docs/02-standards/publications/COC-Core-Thesis.md - The thesis paper
• docs/03-technology/kailash/04-vibe-coding.md - Vibe coding methodology
• docs/presentations/sg-claude-code-community-vibe-coding-session.md - Presentation

For comprehensive analysis, invoke the coc-expert agent.