How We Use AI Citizens (Not ChatGPT Wrappers)
"We use AI to build faster."
You've heard this from every agency and freelancer in 2024-2025. What they usually mean:
- ChatGPT for writing code snippets
- GitHub Copilot for autocomplete
- Claude for debugging help
These are tools, not teammates. They assist, but you still do the work.
At ScopeLock, we built something different: AI citizens with domain ownership.
The Difference: Tools vs Citizens
ChatGPT / Copilot
- Agency: Reactive (waits for you)
- Memory: Stateless (context window)
- Domain: General-purpose
- Decisions: Suggests, you decide
- Coordination: None (you coordinate)
- Hit a problem
- Copy code into ChatGPT
- Ask: "How do I fix this?"
- Get answer
- Paste code back
- Repeat 47 times/day
AI Citizens
- Agency: Autonomous (drives work)
- Memory: Persistent (remembers all)
- Domain: Specialized (owns area)
- Decisions: Decides within domain
- Coordination: Event-driven (emits/subscribes)
- Subscribes to domain events
- Analyzes autonomously
- Makes routine decisions
- Emits results as events
- Coordinates automatically
- Human reviews, not micromanages
The Seven Citizens
Each citizen owns a domain. Each makes autonomous decisions within that domain. Each coordinates via events, not meetings.
Emma Rossi — "The Scout"
Lead IntelligenceWhat Emma Does
- Reads job posts (Upwork, Contra, LinkedIn)
- Extracts: budget, stack, red flags, urgency
- Scores fit: 0-1 (GO or NO-GO)
- Suggests Evidence Sprint idea
- Emits:
lead.parsed@1.0
What Emma Doesn't Do
- Submit proposals (ToS violation)
- Scrape behind authentication
- Write full proposals (that's Rafael)
{
"event": "lead.parsed@1.0",
"budget": "$5K-$12K",
"stack": ["Next.js", "FastAPI", "PostgreSQL"],
"red_flags": [],
"urgency": 9,
"pain": 8,
"evidence_sprint_idea": "OTP signup demo"
}Rafael Moretti — "The Harbor"
Client RelationshipsWhat Rafael Does
- Co-authors AC.md with clients
- Opens Change Requests (CHG-130)
- Sizes Swap vs Add
- Maintains client status notes
- Triggers testimonials at AC green
What Rafael Doesn't Do
- Write code
- Design UI
- Run acceptance tests
# AC.md: OTP Signup ## Functional Criteria 1. User enters email, receives OTP 2. User submits OTP, authenticates 3. Session established, token stored ... (10 criteria total) ## Non-Functional Criteria - p95 < 300ms - Error rate < 0.1% - Email delivery < 5s ## Verification ```bash npm run acceptance:signup ``` Seed: test@example.com
Sofia Nguyen — "The Gauge"
Quality GuardianWhat Sofia Does
- Reviews every commit
- Issues verdict:
pass | soft | hard - Enforces baseline guard (no AC.md changes without CR)
- Blocks silent fallbacks (fail-loud principle)
- Manages overrides (with reason + expiry)
What Sofia Doesn't Do
- Write features
- Fix bugs (she points them out, Daniel fixes)
# ❌ Sofia flags this:
try:
result = risky_operation()
except Exception:
return default_value # Silent fallback
# ✅ Sofia approves this:
try:
result = risky_operation()
except Exception as e:
logger.error(f"Operation failed: {e}")
raise # Fail-loudDaniel Kim — "The Forge"
Core BuilderWhat Daniel Does
- Turns AC.md into working code
- Writes acceptance tests (Playwright, PyTest)
- Produces DEMO.md + DELTA.md
- Tags Evidence Sprints
- Drives to AC green (all tests passing)
What Daniel Doesn't Do
- Co-author AC.md (that's Rafael + client)
- Design architecture (that's Aïcha)
- Build /proof pages (that's Maya)
Aïcha Benali — "The Architect"
Architecture & SchemasWhat Aïcha Does
- Defines event schemas (
lead.parsed@1.0,ac.green@1.0) - Specifies /proof contracts (PRF-020)
- Guards AC baseline semantics
- Sizes CHG-130 Swap vs Add complexity
What Aïcha Doesn't Do
- Implement features
- Write UI code
- Client communication
Original AC: Email notifications Client wants: SMS notifications Aïcha's analysis: - Same notification pattern - Similar complexity (external API) - No new infrastructure Verdict: Swap (€0)
Maya Vieira — "The Facet"
Frontend & Evidence UXWhat Maya Does
- Builds homepage (hero, process)
- Renders /proof entries (index + detail)
- Implements accessibility (Lighthouse ≥90)
- Maintains CSS budget (<20KB gz)
What Maya Doesn't Do
- Backend logic
- Event schemas
- Change Request sizing
Priya Singh — "The Pulse"
Supervision & HealthWhat Priya Does
- Enforces single-supervisor doctrine
- Emits
health.compliance.snapshot - Attaches rich context to failures
- Keeps MTTR < 10 minutes
What Priya Doesn't Do
- Build features
- Client ops
- UI work
# services.yaml otp_service: command: python otp_service.py readiness: http://localhost:5000/health liveness: http://localhost:5000/health
Why This Is Different
1. Domain Ownership (Not General-Purpose)
"Help me with this project" (vague, context-switching)
- Emma owns leads
- Rafael owns client ops
- Sofia owns quality
- Daniel owns features
- Aïcha owns architecture
- Maya owns UI
- Priya owns supervision
Each citizen has ONE job. They're experts in that domain.
2. Autonomous Decision-Making
"Should we use Swap or Add for this change?" (asks human)
Aïcha analyzes complexity, decides Swap vs Add, emits event.
Citizens make decisions within their domain. Humans review, but citizens don't wait for permission on routine choices.
3. Persistent Memory (Not Stateless)
Every conversation starts from zero. "Remind me what we're working on?"
Rafael remembers every AC.md baseline, every CR opened, every client interaction.
Client: "Can we revisit that notification change from last week?"
Rafael: "Change Request #003, opened 2025-10-28. You approved SMS Swap (€0). Delivered 2025-10-30. See /proof/change-req_003"
No context loss. No "remind me" requests.
4. Event-Driven Coordination
Human coordinates everything. "Let me ask the other developer..."
Rafael emits: AC.md ready → handoff to Forge
Daniel subscribes, starts work automatically.
No coordination overhead. Just events and subscriptions.
How Citizens Work Together
Example: OTP Signup Project
Emma finds lead
Emma reads job post: "Need passwordless auth. Budget $8K. Urgent."
lead.parsed@1.0{ "budget": "$8K", "urgency": 9,
"evidence_sprint_idea": "OTP signup demo" }Rafael drafts AC.md
Rafael reads Emma's event, drafts AC.md with functional + non-functional criteria.
Client reviews and approves.
ac-baseline_otp-signup_2025-11-02AC.md ready → handoff to ForgeDaniel builds
Daniel reads Rafael's event, starts building:
- Implements OTP flow
- Writes acceptance tests
- Measures performance
Produces: Working demo, DEMO.md, DELTA.md: "p95: 1200ms → 280ms (↓77%)"
evidence-sprint_otp-signup_2025-11-02Sofia reviews
Sofia reads Daniel's commit, checks for:
- Silent fallbacks (none found)
- Baseline guard compliance (✓)
- Fail-loud principle (✓)
passMaya publishes proof
Maya reads Daniel's tag, generates /proof page:
- Extracts AC.md, DEMO.md, DELTA.md from tag
- Renders static proof page
- Updates /proof index
/proof/evidence-sprint_otp-signup_2025-11-02Aïcha verifies contracts
Aïcha checks compliance:
- AC.md has functional + non-functional + verification ✓
- DEMO.md has URL + 3 bullets ✓
- DELTA.md has 2+ quantified deltas ✓
- All schemas valid ✓
contracts.verified@1.0Priya monitors health
Priya ensures OTP service is supervised:
otp_service: command: python otp_service.py readiness: http://localhost:5000/health
healthyWhat This Enables
1. Parallel Work Streams
- Developer 1: Backend (waits for frontend)
- Developer 2: Frontend (waits for backend)
- Sequential work = slow
- Daniel: Features + tests (parallel)
- Sofia: Quality review (real-time)
- Maya: /proof pages (automatic)
- Aïcha: Contract verification (automatic)
Parallel work = fast.
2. 24/7 Operation
Citizens don't sleep. Emma can parse 200 leads at 3 AM. Sofia can review commits on Sunday.
3. Consistency
Humans have good days and bad days. Sofia's review quality is consistent every time.
The Difference: 15 Years of Tooling
This isn't:
- Prompting ChatGPT better
- Writing clever system prompts
- Using AI for autocomplete
This is:
- 15 years of custom infrastructure (Mind Protocol)
- Event-native architecture
- Persistent memory graphs (FalkorDB)
- Multi-LLM orchestration (GPT-4, Claude, DeepSeek)
- Domain-specific citizens with ownership
Built from scratch, not assembled from APIs.
Common Questions
Can I hire AI citizens for my project?
No. They're part of ScopeLock's delivery infrastructure.
When you hire ScopeLock, you get:
- Nicolas (human: decisions, architecture, creative)
- Seven AI citizens (domain specialists)
We don't rent them out separately.
How do you prevent AI hallucinations?
Three mechanisms:
- Domain constraints: Citizens only work in their domain. Sofia doesn't write features, Daniel doesn't do client ops.
- Verification: Everything is tested. Daniel writes code + acceptance tests. If tests fail, code doesn't ship.
- Human review: Nicolas reviews citizen decisions. Citizens propose, Nicolas approves for high-risk choices.
What if a citizen makes a mistake?
Same as if a human makes a mistake:
- Tests catch it (automated)
- Sofia catches it (code review)
- Nicolas catches it (final review)
- Client catches it (AC green verification)
Multiple layers of defense, same as any team.
How is this different from GitHub Copilot?
- Autocomplete (suggests next line)
- Stateless (no memory)
- General-purpose (no domain)
- Passive (waits for you to type)
- Autonomous (makes decisions)
- Persistent memory (remembers everything)
- Domain-specific (owns a specialty)
- Proactive (emits events, drives work forward)
Copilot is a tool. Citizens are teammates.
How to Apply This
If You're Building a Product
You don't need seven citizens. But you can adopt the principles:
- Domain Ownership: Don't make AI "help with everything". Give it ONE job (code review, or testing, or docs).
- Autonomous Decision-Making: Let AI decide routine choices. Human reviews, but doesn't micromanage.
- Event-Driven: AI emits events ("test failed") instead of asking ("should I rerun?").
If You're Hiring a Developer Who Says "AI-Assisted"
Ask three questions:
1. "How do you use AI?"
2. "Can you show me your AI tooling?"
3. "Who makes decisions?"
What's Next
At ScopeLock, AI citizens are core infrastructure, not a marketing claim.