I Couldn't Buy It So I Built It: Citizen Developers Building AI Applications with Coinbase
Ai4
AI-assisted summary of I Couldn't Buy It So I Built It: Citizen Developers Building AI Applications with Coinbase — original source. Check the original for full context.
Source published:
Detailed notes
## Background Published on YouTube by Ai4 on August 20, 2026, this presentation features Coinbase's Robert Greisemer (Sr. SRE, Core AI Infrastructure) and Nina Eisenberg (Associate General Counsel, Workplace Ethics & Investigations). The session details how a non-technical domain expert built an internal AI case management application after commercial vendors failed to meet her team's needs, examining the platform engineering and security guardrails required to safely transition citizen builds into enterprise-ready tools.
## TL;DR When an inflexible $75,000 vendor tool and a surge in workplace investigations threatened to overwhelm her team, lawyer Nina Eisenberg used Claude Code to rapidly build 'Casebase,' an AI-assisted investigation and precedent-tracking suite. Although the local prototype effectively replaced legacy software and saved weeks of manual work, an engineering review by SRE Robert Greisemer revealed significant hidden risks, including conflicting frontend frameworks, pseudo-authentication, and missing audit logs. Evaluating the high operational overhead of dedicated 24/7 on-call rotations, the team implemented a pragmatic local hardening stopgap while architecting an opinionated enterprise platform to enforce secure guardrails for future citizen developers.
## Atmosphere & style The presentation carries a humorous, candid, and highly collaborative energy, driven by the charming dynamic between an admittedly non-technical philosophy major and a veteran infrastructure engineer. Nina's self-deprecating anecdotes—such as comparing AI debugging loops to Janet from *The Good Place* repeatedly handing out cacti—contrast perfectly with Robert's pragmatic warnings about fake RBAC and the hidden millions behind production on-call rotations. It feels refreshingly grounded and authentic, moving from the exciting high of non-engineer empowerment to a clear-eyed blueprint for enterprise safety and technical partnership.
## Key takeaways - [00:04](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=4s) The barrier to creating software has collapsed due to generative AI coding tools, but the barrier to running, securing, and maintaining enterprise applications in production remains unchanged. - [02:17](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=137s) Internal cost centers often tolerate broken, manual micro-workflows because building custom software historically offered low ROI, but unmanaged citizen development risks introducing severe vulnerabilities. - [04:27](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=267s) Rigid vendor platforms that refuse custom integration requests can prompt domain experts to build AI-native alternatives that directly fit specialized organizational workflows. - [08:29](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=509s) Legal and analytical domain training—specifically precise writing, clear specifications, and exhaustive edge-case thinking—translates directly into effective prompt engineering and AI agent design. - [11:44](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=704s) AI-native tools built from a clean slate can dramatically outperform legacy software, reducing complex drafting tasks from hours to minutes while incorporating semantic search across historical records. - [13:48](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=828s) Building prototypes independently outside enterprise boundaries is frictionless, but achieving enterprise reliability requires security reviews, access controls, and infrastructure integration. - [15:31](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=931s) 'Vibe-coding' with AI can easily produce chaotic architectures, including mismatched frontend frameworks and pseudo-RBAC authentication that appears functional while leaving major security holes open. - [19:00](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1140s) Expecting non-technical builders to execute complex DevOps remediation plans (such as LDAP provisioning and cloud database migrations) breaks the citizen developer model. - [21:08](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1268s) Because modern AI applications leverage connected tools and enterprise search, exposed secrets or compromised API credentials exponentially amplify an attacker's blast radius across corporate systems. - [22:51](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1371s) Transitioning internal prototypes to 24/7 enterprise production introduces massive hidden operational overhead, such as audit logging, compliance, and multi-engineer on-call rotations. - [26:03](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1563s) A hardened local setup with automated centralized backups can serve as a pragmatic stopgap for single-user internal tools without incurring full production maintenance costs. - [30:05](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1805s) Platform teams must provide hyper-opinionated coding environments that steer users to existing workflow tools or enforce architectural standards and guardrails upfront rather than post-hoc. - [34:13](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=2053s) Citizen developers must develop architectural literacy to recognize code smells and prevent AI sycophancy, where models double down on incorrect assumptions and generate bloated codebases. - [35:44](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=2144s) Generalized AI agents connected to enterprise search engines like Glean can effectively index internal playbooks and guide builders without the maintenance overhead of multiple specialized sub-agents. - [37:43](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=2263s) Early collaboration between non-technical domain specialists and platform SRE teams is essential to turn working AI prototypes into enterprise-grade applications safely.
## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=4s) Philosophy Majors, SREs, and the Collapsing Barrier to Software
Nina Eisenberg opens with an admission of her non-technical roots: having studied philosophy and Russian literature at a liberal arts college, she can write a beautiful essay, but she "cannot fix the Wi-Fi." A few months prior, she did not even know what a terminal was. Yet, she managed to build an AI application that replaced an enterprise case management platform costing Coinbase $75,000 a year. As Associate General Counsel running Workplace Ethics and Investigations at Coinbase for nearly seven years, Nina handles sensitive, high-stakes matters involving harassment, discrimination, security issues, insider threats, and policy violations. Her day-to-day work requires deep domain expertise and empathy, not writing software. Until January 2026, her entire interaction with artificial intelligence was limited to casual chatbot conversations.
```mermaid flowchart LR accTitle: The Two Ends of the Enterprise AI Spectrum subgraph Domain ["Domain Expertise"] A["Nina Eisenberg<br/>(Legal & Investigations)"] A --> B["Understands Problem,<br/>Edge Cases & Precedent"] end subgraph Platform ["Infrastructure & Safety"] C["Robert Greisemer<br/>(Core AI & SRE)"] C --> D["Deployment, Security,<br/>RBAC & Guardrails"] end B --> E["Enterprise-Ready AI Application"] D --> E ```
To bridge the gap between a prototype and a secure corporate deployment, she partnered with Robert Greisemer, a Senior Site Reliability Engineer on Coinbase's Core AI Infrastructure team with nearly 18 years of experience across security and AI platform engineering. Together, they frame the core reality facing modern organizations: "The barrier to building software has collapsed while the barrier to running it hasn't moved." Domain experts no longer need to wait in line for internal engineering resources or settle for generic third-party tools that fail to meet their workflows.
- **Speaker Backgrounds:** Nina Eisenberg (AGC, Workplace Ethics & Investigations, ~7 years at Coinbase) and Robert Greisemer (Sr. SRE, Core AI Infrastructure, ~18 years in tech). - **Core Insight:** Domain specialists can now translate their problem-space knowledge directly into working code using AI, but deploying it safely requires dedicated infrastructure and security guardrails.
---
[02:17](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=137s) The Cost Center Problem and the Guardrail Dilemma
Robert explains that during his years as a consultant, he constantly witnessed broken, manual enterprise processes that impacted only two or three individuals. For instance, an employee might print out accounts billable, handwrite each line item onto paper, walk it over to the accounts receivable department, and have someone manually re-enter it into another system. Companies routinely tolerated such absurd inefficiencies because the work still got done, and building custom software internally carried zero financial return on investment. Because departments like legal and operations operate as cost centers rather than revenue generators, their bespoke operational bottlenecks were consistently deprioritized.
With generative AI and coding agents, citizen developers can now eliminate these micro-inefficiencies on their own. However, Robert cautions that handing powerful AI tools to novice developers without established boundaries introduces severe corporate risk: "AI in the hands of a novice citizen developer with no guardrails, it ends in security vulnerabilities." Nina playfully embraces the label ("Nice to meet you all. I'm the cost center"), underscoring that citizen builders need technical partners to turn local scripts into safe enterprise systems.
- **Historical Enterprise Barrier:** Custom internal tools were rarely built for small departmental workflows because they offered no quantifiable ROI or headcount reduction. - **The Modern Trade-off:** Citizen developers can resolve their own bottlenecks, but unmanaged builds risk exposing sensitive data or creating architectural vulnerabilities.
---
[04:27](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=267s) January 2026: Doubled Caseloads and a $75,000 Vendor Saying "No"
In January 2026, Nina experienced an unprecedented surge that doubled her standard case volume. Managing high-stakes investigations already required an immense volume of administrative overhead. For every single case, she spent approximately 30 minutes drafting an investigation plan, 30 minutes preparing each interview outline, and another 30 minutes documenting the case findings. Across 30 cases in a single month, this routine administrative paperwork completely consumed her calendar, pulling her away from high-value strategic decision-making.
```mermaid flowchart TD accTitle: Case Management Administrative Overhead subgraph CaseWorkflow ["Standard Case Overhead (Per Case)"] P["30 min: Investigation Plan"] I["30 min: Interview Outlines"] D["30 min: Case Documentation"] P --> I --> D end CaseWorkflow --> Vol["30 Cases / Month = Crushing Manual Overhead"] Vol --> VendorFail["$75,000/yr Vendor Tool<br/>• No feature support<br/>• No custom builds<br/>• Zero integrations"] ```
To make matters worse, Coinbase was paying $75,000 annually for an external case management software that provided zero workflow assistance or automation. Nina envisioned a tool that could connect into Coinbase's existing ecosystem, automatically draft standard artifacts, and streamline documentation. However, when she approached the vendor with requests to build custom features, extend the platform, or integrate with internal systems, the vendor's response across the board was an emphatic "no." Faced with rigid vendor constraints and an unsustainable workload, she chose to build the system herself.
- **Caseload Breakdown:** ~30 cases per month, requiring 30 minutes for an investigation plan, 30 minutes per interview outline, and 30 minutes for final documentation. - **Vendor Limitations:** Refused feature enhancements, lacked developer extension points, and offered no third-party integrations despite the $75,000 annual price tag.
---
[06:20](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=380s) The Nine-Hour Sunday: Claude Code, Hidden Passwords, and Exiting Vim
Driven by necessity, Nina dedicated nine straight hours on a Sunday to working with Claude AI. Describing the experience as deeply humbling after spending 20 years earning academic degrees, she began by laying out her day-to-day responsibilities and asking whether AI could assist. Claude instructed her to install Claude Code, which immediately presented foundational hurdles: she did not know what a terminal window was, and once she opened one, she struggled with terminal password prompts because the characters remained invisible as she typed.
Despite running into basic command-line obstacles—including the classic challenge of learning how to exit Vim—Nina emerged from that single nine-hour session with a working, AI-enabled productivity suite. Asking Claude to estimate the efficiency gains of the code produced that day yielded a total savings of four weeks of working time per year, with a single sub-project accounting for two full weeks saved. Robert notes that while getting a local build running on a laptop is a major milestone, "You can't just have something run on a lawyer's laptop and say, 'Good enough, everybody have fun. We've opened up an ngrok tunnel to it.'" Turning that functional local prototype into an enterprise-grade service required a complete operational hardening layer.
- **Initial Tooling:** Claude AI and Claude Code CLI. - **Time Investment vs. Return:** 9 hours of conversational coding yielded an estimated 4 weeks of saved working time annually. - **Operational Reality:** Local execution via an ngrok tunnel is insufficient for enterprise compliance, security, and stability.
---
[08:29](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=509s) Building the Four Core Tools and the "Janet's Cactus" Workflow
Nina started by tackling her smallest viable problem: replacing the physical notebook she had relied on for years with a simple dashboard tracking case touchpoints and next steps. From there, she expanded the suite into four distinct capabilities that ultimately functioned as a unified investigation platform:
```mermaid flowchart TD accTitle: Four Core Components of the Investigations AI Suite subgraph Suite ["Custom Investigation AI Suite"] D1["1. Case Tracking Dashboard<br/>Replaced physical paper notebook"] D2["2. Precedent & Meeting Brief Engine<br/>Semantic search across 6 years of records"] D3["3. Interactive Annual Executive Report<br/>Reduced 40-60 hrs to a few hours"] D4["4. Custom 'Junior Associate' Agent<br/>First-draft generation for all artifacts"] end D1 --- D2 --- D3 --- D4 ```
1. **Case Tracking Dashboard:** Replaced pen-and-paper tracking with a structured system monitoring when cases were last touched and identifying immediate next actions. 2. **Precedent & Meeting Brief Engine:** Synthesized historical case data to automatically pull semantically similar matters from six years of Coinbase records, allowing Nina to advise leaders with concrete historical precedent. 3. **Executive Annual Report Generator:** Transformed a grueling annual reporting process that previously took 40 to 60 hours into a few hours of work, outputting an interactive HTML presentation that kept executives engaged. 4. **AI "Junior Associate" Agent:** Grounded in six years of documented investigation history, this agent drafts every single initial investigative artifact.
Nina demystifies her development process as a continuous feedback loop: whenever she hit an error, she took a screenshot, pasted it into Claude, asked "What do I do now?", and executed the next instruction. She compares the experience to the character Janet from the comedy *The Good Place*, who, when broken, repeatedly hands people a cactus instead of a glass of water—eventually, through iteration, the right output arrives. Nina realized that the primary bottleneck was never the underlying technology, but rather the clarity with which she could express her logic. Because legal training centers on precise articulation and edge-case analysis, her legal background proved to be the ultimate programming foundation: "Claude didn't replace my expertise. It just made my expertise portable."
- **Efficiency Highlight:** The annual executive report build cut preparation time from 40–60 hours down to a handful of hours while upgrading the deliverable to an interactive HTML format. - **Historical Data Integration:** Leveraged six years of historical investigation records to power semantic search and baseline drafting. - **The Core Skillset:** Precise writing and exhaustive edge-case thinking directly translate into effective prompt engineering and agent system design.
[11:44](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=704s) Building Casebase: Replacing a $75k Legacy Tool with an AI-First System
Drawing a direct parallel between the disciplines, Nina notes that legal and engineering are surprisingly similar: both revolve around writing detailed specifications and documentation. In both worlds, failing to clearly articulate what needs to be built leads to confusion and a terrible end product. The exact same principle applies when working with AI coding agents: the more precise and specific you are with your prompts and requirements, the better the resulting software will be.
Nina consolidated her four separate workflow side projects into a single unified application named **Casebase**. At its core, Casebase is a comprehensive case management system designed to track high volumes of workplace investigations—effectively replacing an off-the-shelf vendor solution that had been costing Coinbase $75,000 per year, but with the critical advantage that it actually matched her real investigation workflow and was built in just a few weeks.
Beyond standard case management, Casebase automated the most time-consuming drafting tasks and gave Nina her time back. It also introduced two critical enterprise capabilities: semantic search across past internal cases to ensure precedent consistency (preventing investigators from wondering, *"Wait, did I see this in 2022?"*), and a continuously updating analytics dashboard that eliminated the need to compile manual annual reports. Crucially, the system was wired directly into Coinbase’s internal production ecosystem rather than existing as an isolated prototype.
```mermaid flowchart TD accTitle: Casebase Architecture and Capabilities subgraph INTAKE["Case Intake & Documents"] A["Intake Notes"] --> B["Investigation Plans<br/>(Under 2 mins vs. 30-60 mins)"] A --> C["Interview Outlines<br/>(Under 1 min)"] A --> D["Structured Reports & Determinations<br/>(Minutes vs. 5-10 hours)"] end
subgraph ENGINE["Casebase Core Platform"] B & C & D --> E["Case Management System"] E --> F["Precedent Search & Consistency"] E --> G["Live Analytics Dashboard"] end
subgraph INFRA["Coinbase Infrastructure"] E --> H["Glean (Policy Search)"] E --> I["LLM Gateway (AI Routing)"] E --> J["Google Workspace"] end ```
- **Efficiency Gains:** Investigation plans drafted from intake notes in under 2 minutes (down from 30–60 minutes); interview outlines generated in under 1 minute; multi-page structured reports with credibility findings and determinations completed in minutes (down from 5–10 hours). Nina likens this to having a junior associate who *"never sleeps and never tells me off."* - **Enterprise Integrations:** Glean for company policy retrieval, Coinbase's internal LLM Gateway for secure model inference, and Google Workspace for document flows.
---
[13:48](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=828s) Vendor Reactions and the Tale of Two Apps: Casebase vs. Violet
When Nina demonstrated Casebase to the external software vendor whose contract was up, they immediately ceased trying to push for a renewal. More importantly, the vendor candidly admitted a fundamental software reality: building an AI-native system from scratch is radically different from attempting to bolt AI features onto a legacy architecture that was never engineered for it. Starting with a blank canvas allowed a non-engineer to leapfrog a mature commercial product in a matter of weeks.
To test the boundaries of what was possible, Nina built a second, even more sophisticated personal project on her own time called **Violet**. Violet could handle massive, complex cases that would ordinarily blow past standard LLM context windows. Yet building Violet independently proved vastly easier than building Casebase inside the enterprise. Outside corporate walls, there were no hurdles between a builder and the next feature; inside Coinbase, shipping software required stringent permissions, security reviews, and multi-team approvals.
> *"AI let me build the thing. What it could not do was make it safe to trust at enterprise scale. The gap between 'I built it' and 'you can rely on it' is exactly where Robert comes in."*
---
[15:31](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=931s) Where Vibes Meet Deploying: Diagnosing Frontend Chaos and Pseudo-RBAC
Taking the stage as the platform enabler, Robert Greisemer describes how executive enthusiasm for Nina’s tool triggered a deep architectural investigation into the reality of citizen development. In modern engineering organizations, teams rely on established "golden paths" or "paved roads"—standardized stacks, frameworks, and deployment rails. However, domain experts cannot be expected to know the difference between GraphQL and direct database queries, or why a production system cannot use Google Sheets as its primary data store (a common workaround chosen by non-engineers simply because they want built-in pivot tables). While Nina had at least opted for SQLite, inspecting her codebase revealed what happens when "vibes" collide with production engineering.
```mermaid flowchart LR accTitle: Citizen Dev MVP vs Enterprise Standards subgraph MVP["Vibe-Coded Citizen Build"] FE1["AngularJS + Vue.js + Vite"] BE1["Next.js Backend"] DB1["Local SQLite"] AUTH1["Pseudo-RBAC (No real validation)"] end
subgraph PROD["Coinbase Production Standard"] FE2["ReactJS"] BE2["Golang Backend"] DB2["Hosted DB Infrastructure"] AUTH2["Okta SAML & LDAP Group RBAC"] end
MVP -.->|"Platform Engineering Gap"| PROD ```
At the UI level, the application ran locally and every button worked as expected. But under the hood, Claude had somehow stitched together three conflicting frontend frameworks—AngularJS, Vue.js, and Vite—into a single application, with an entire backend running in Next.js instead of Coinbase's internal Go backend standard.
More dangerously, the AI had implemented an illusion of Role-Based Access Control (RBAC). When Nina logged in, the UI displayed her profile picture and username, giving the appearance of secure authentication. But when Robert tested the login form by entering complete "gobbledegook" into the credentials field, the app granted full administrative access: *"Guess what? I'm Nina now."*
---
[19:00](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1140s) The Citizen Developer Dilemma: Why Agent Plans Still Overwhelmed Non-Engineers
To bridge the gap between Nina’s prototype and Coinbase’s paved roads, the engineering team built dedicated gap-analysis agents. These agents ingested the entire codebase and generated a step-by-step remediation plan detailing every architectural change required. However, the plan fell into the classic engineering trap: it spoke in heavy technical jargon and assumed software engineering competencies that a workplace investigations lawyer did not possess.
Handing a non-technical builder a list of infrastructure mandates created immediate friction: - **Directory & Group Management:** Instructing Nina to configure an LDAP group meant navigating internal LDAP request systems and permission matrices. - **Single Sign-On (SSO):** Setting up production SAML authentication required configuring Okta integrations rather than just writing application code. - **Database Provisioning:** Moving away from SQLite required spinning up managed cloud database instances.
While specialized agent teams managed to fix the majority of critical vulnerabilities and get the service deployed, the exercise made one fact abundantly clear: asking a citizen developer to "yolo" their way through infrastructure configuration, LDAP consoles, and backend migrations is fundamentally unsustainable. Citizen developers understand that an app has a frontend and a backend; expecting them to operate like seasoned DevOps engineers breaks the model.
---
[21:08](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1268s) Shifting to Platform-First: Hardening, Secrets Management, and Cascading AI Risks
The lessons learned from Casebase forced Coinbase's platform team to shift their entire philosophy from *post-hoc hardening* to *building for the platform first*. By the end of the initial remediation, Casebase had achieved genuine enterprise compliance: functional RBAC tied to LDAP, a fully hosted and managed database, and all hardcoded API credentials scrubbed from Git repositories and moved into a centralized secrets management system.
Robert stresses that secrets management is especially existential in the era of interconnected AI agents. Modern AI applications do not operate in silos; they leverage tool calling to query enterprise knowledge bases like Glean, access Google Drive files, and trigger downstream communications. A compromised credential in an AI workflow does not remain an isolated bug—it causes a catastrophic blast radius across the enterprise network.
```mermaid flowchart TD accTitle: Cascading Blast Radius in Connected AI Systems A["Compromised API Key in Casebase Git Repo"] --> B["Attacker Impersonates Nina"] B --> C["Tool Calls to Glean"] C --> D["Unauthorized Queries of Confidential Policy & Legal Data"] B --> E["Slack Tool Calling Integration"] E --> F["Social Engineering & Fraud (e.g. Requesting Gift Cards)"] ```
- **Cascading Vulnerability:** If Nina’s API keys were leaked, an attacker could impersonate an Associate General Counsel across connected downstream tools. - **Autonomous Tool-Call Exploitation:** Attackers could query highly confidential legal documents directly via Glean or send authenticated Slack messages pretending to be Nina instructing employees to take urgent actions. - **Core Platform Takeaway:** Because interconnected AI systems exponentially amplify the blast radius of any single configuration error, platform guardrails must be baked into the foundation automatically, rather than relying on citizen developers to discover and fix them after the fact.
[22:51](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1371s) Auditing, Compliance, and the Hidden Costs of Production
Beyond baseline security concerns, enterprise viability hinges on auditing and compliance. In a regulated financial utility like Coinbase, an application cannot simply let users perform tasks without capturing granular logs of who did what and when. If an incident or breach were to occur and engineering had to report that no logs existed, the fallout would be catastrophic.
```mermaid flowchart TD accTitle: Citizen App vs Production Reality Flow subgraph MVP["Citizen App Reality"] A["Vibe-Coded Prototype"] --> B["Single User Local Run"] B -.->|"Lacks"| C["Audit Logs & Observability"] end
subgraph ProdReq["Enterprise Production Overhead"] D["24/7 PagerDuty Rotation"] E["Min. 3 On-Call Engineers"] F["$2M+ Team Investment"] end
MVP -->|"Gap to Bridge"| ProdReq ```
When evaluating whether Nina's case management tool should be promoted to full production, Robert and the team realized the hidden operational costs. Production requires ongoing maintenance, alert triage, and dedicated on-call rotations. Citizen developers do not sign up to be woken up by PagerDuty at 2:00 a.m. for alert notifications. Nina candidly noted that her workday ends strictly at 4:30 p.m. ("I turn into a pumpkin at 4:30 every day").
Maintaining production applications at scale creates a significant financial threshold: - A single engineer can realistically maintain roughly 15 production applications. - A functional on-call rotation requires a minimum of three engineers to prevent burnout. - Supporting dedicated on-call staffing demands an organizational investment well exceeding $2 million. - Moving the application to production proved far more expensive than the original $75,000 vendor quote, defying the initial hope that vibe-coding would provide a cheap shortcut.
---
[26:03](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1563s) The Stopgap Compromise: Hardening Local Execution
Rather than blocking the project and forcing Nina back to an inadequate legacy workflow—or resorting to standard security threats ("Do what we say or we'll fire you", which Nina joked would require sending a calendar invite to herself to conduct her own termination)—the engineering team designed a pragmatic stopgap. Because the app worked locally for Nina as the company's sole investigator handling that specific workload, they focused on mitigating data retention and disaster recovery risks.
```mermaid flowchart LR accTitle: Local Hardening Stopgap Workflow subgraph Client["Local Environment"] App["Local App / Podman Container"] CaseData[("Active Case Data")] App --> CaseData end
subgraph Central["Centralized Storage"] Backup["Automated Daily Backup"] end
CaseData -->|"Daily Sync on Startup"| Backup ```
They implemented an automated backup feature that triggers upon application startup, safely uploading case records to centralized storage. If her laptop crashes, at most a few hours of work are lost. This balanced risk against unrealistic engineering standards; pursuing eight nines of uptime at massive expense makes no sense for internal tools with modest financial footprints.
- **Containerization adjustments:** To avoid Docker Desktop enterprise licensing fees, Robert advised switching to Podman as a free, open-source alternative. - **Headcount realities:** When asked if her solo setup was due to low case volume, Nina clarified that after case volume doubled in January with no added headcount, AI became the only viable path to scale her team's capacity.
---
[28:12](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1692s) Production Non-Negotiables and Architecture Gaps
The experiment proved that while AI democratizes *who* can write code, it does not change *what production requires*. Citizen developers deploying raw code without safeguards risk major vulnerabilities, unmetered loops, and massive API bills. Nina illustrated this by sharing how a personal passion project—a trip planner that generated creatures for her kids—accidentally ran up an $80 API bill in moments because there were no cost guards in place.
Enterprise applications require non-negotiable fundamentals: - **Data Protection & Access Auditing:** Every read, write, and administrative action must be recorded and verifiable. - **Dependency & CVE Management:** Large language models are typically trained on snapshots from 6 to 12 months prior. Unless directed to fetch current versions, they default to outdated software packages riddled with known CVEs (Common Vulnerabilities and Exposures). - **Rate Limiting & Secret Hygiene:** API keys and endpoints must be shielded to prevent public exploitation and runaway billing.
---
[30:05](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1805s) The Hyper-Opinionated Platform and "Freedom Within Guardrails"
To bridge the gap between ad-hoc local tools and production readiness, the infrastructure team set out to build a centralized platform: a hyper-opinionated AI coding assistant designed to enforce enterprise guardrails upfront.
```mermaid flowchart TD accTitle: Opinionated Citizen Developer Assistant Flow UserPrompt["Citizen Developer Prompt"] --> AIPlatform["Hyper-Opinionated AI Assistant"]
AIPlatform --> Decision{"Use Case Evaluation"}
Decision -->|"Simple Task / Glue Code"| ExistingTool["Redirect to Existing Tools\n(e.g., n8n Workflows)"] Decision -->|"Valid Custom App"| Guardrails["Enforce Architecture & Standards\n• Standardized Tech Stack\n• Built-in Auth & Logging\n• Pre-flight Security Scans"]
Guardrails --> SafeProd["Safe Production Deployment"] ```
When a citizen developer requests a simple integration—such as copying data between Google Sheets and Google Docs—the assistant steers them away from writing custom software, directing them instead toward existing workflow automation tools like n8n and generating the workflow on their behalf. For legitimate custom applications, the assistant scaffolds the project according to strict architectural standards, mitigating language sprawl across thousands of internal tools.
Reflecting on the experience, Nina joked that she "never wants to set any settings in Cloudflare ever again" and emphasized the value of consulting engineers early to define what good architecture looks like. Robert noted that traditional developer documentation—often 55-step Confluence pages filled with stale screenshots and unexplained pull request links—fails citizen developers. Empowering non-engineers requires intelligent agents that plan, scaffold, and execute within defined guardrails, putting an end to "yoloing code to production."
---
[33:27](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=2007s) Q&A: Navigating Blind Spots as a Citizen Developer
The floor opened to audience questions. A fellow citizen developer asked how an isolated builder without an SRE partner like Robert or an enterprise platform like Coinbase's can identify their architectural blind spots, discover frameworks, and safely close technical gaps when building solo.
[34:13](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=2053s) The Hallucination Trap and Spotting Bad Code
When non-technical builders lean entirely on AI coding assistants like Claude Code, they inevitably run into sycophancy and hallucinations. AI models have a tendency to agree with user prompts and validate incorrect assumptions: if a user suggests an issue might be in a specific place, the model will often double down, insist the user is right, and fabricate an explanation for why. For citizen developers building without dedicated engineering support, the single most critical recommendation is to learn the foundational concepts of software architecture. Builders do not need to know how to write syntax from scratch, but they must know how to recognize bad code and architectural smells.
A striking example occurred in Nina Eisenberg's prototype UI. When she prompted the model to change a single button color across all pages—an operation that should ideally touch a single line or class in a shared CSS stylesheet—the model produced a massive 1,400-line diff. The underlying reason was that the AI assistant had haphazardly stitched together three completely different front-end frameworks across the application's pages, duplicating styles and components across the entire codebase rather than maintaining a clean, unified design system.
```mermaid flowchart TD accTitle: AI Hallucination and Spaghetti Code Loop subgraph S1["Citizen Developer Workflow"] A["User Inferences & Assumptions"] --> B["Claude Code Prompt"] B --> C{"AI Sycophancy / Hallucination"} C -- "Doubles down on false premise" --> D["Messy / Bloated Implementation"] end
subgraph S2["Architectural Consequence"] D --> E["3 Disparate Front-End Frameworks"] E --> F["Single Button Color Change"] F --> G["1,400-Line Code Diff"] end ```
- **Model Sycophancy:** AI models often validate user guesses instead of diagnosing the genuine root cause. - **Architectural Literacy:** Citizen developers must know how to spot code sprawl, excessive complexity, and framework mismatch even if they cannot write the code manually. - **CSS Sprawl Example:** A trivial UI button restyling resulted in a 1,400-line change due to multiple overlapping front-end frameworks generated over time.
---
[35:44](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=2144s) Enterprise Playbooks: Generalized vs. Specialized Sub-Agents
During the audience Q&A, an attendee asked whether enterprise digital playbooks—such as Confluence documentation covering front-end, back-end, cybersecurity, and Identity and Access Management (IAM) standards—could be modularized into domain-specific sub-agents to coach citizen developers early in the development lifecycle.
Robert Greisemer explained the trade-offs between deploying specialized sub-agents versus utilizing a single generalized agent equipped with enterprise search retrieval:
```mermaid flowchart LR accTitle: Knowledge Retrieval Architectures for Citizen Development subgraph OptionA["Coinbase Architecture (Generalized)"] G1["Generalized AI Agent"] --> G2["Glean Knowledge Search"] G2 --> G3[("Indexed Enterprise Data & Playbooks")] end
subgraph OptionB["Low Data-Maturity Architecture (Specialized)"] S1["Citizen Developer"] --> S2["Front-End Sub-Agent"] S1 --> S3["Security / IAM Sub-Agent"] S1 --> S4["Back-End Sub-Agent"] end ```
At Coinbase, internal AI agents query Glean, an enterprise search engine that indexes internal company documentation and playbooks across systems. This setup enables a single generalized agent to pull relevant security and infrastructure standards on demand, significantly reducing the overhead of maintaining dozens of individual specialized agents. However, Robert noted that in less mature organizations where documentation quality and playbook cleanliness are low, building specialized sub-agents with strict domain constraints may be more effective.
- **Generalized Agent + Search:** Using an enterprise search tool like Glean allows one generalized model to access up-to-date company playbooks without ongoing sub-agent maintenance. - **Specialized Sub-Agents:** Useful in environments with lower documentation maturity where direct guardrails must be hardcoded for security, IAM, and backend standards.
---
[37:43](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=2263s) Bridging the Gap Between Builders and Engineers
When asked whether she would have pursued the project differently if she had known all the enterprise security constraints from day one, Nina reflected on the early days of her build. At the time, she was experimenting before the term "citizen developer" was widely established and was unaware that infrastructure engineers like Robert were available to partner with domain experts. If that partnership had existed from the beginning, she noted, her application would already be running in production behind Okta authentication rather than operating solely on a local machine.
Robert concluded by encouraging domain experts to actively reach out to platform and infrastructure teams. While engineers sometimes have a reputation for being "grumpy all the time," they are eager to share knowledge, establish secure pathways, and help domain experts turn prototypes into enterprise-grade applications. The speakers then wrapped up the session and invited attendees to continue the discussion in the hallway.
## Notable quotes > [00:04](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=4s) The barrier to building software has collapsed while the barrier to running it hasn't moved. — Robert Greisemer
> [02:17](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=137s) AI in the hands of a novice citizen developer with no guardrails, it ends in security vulnerabilities. — Robert Greisemer
> [02:17](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=137s) Nice to meet you all. I'm the cost center — Nina Eisenberg
> [06:20](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=380s) You can't just have something run on a lawyer's laptop and say, 'Good enough, everybody have fun. We've opened up an ngrok tunnel to it.' — Robert Greisemer
> [08:29](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=509s) Claude didn't replace my expertise. It just made my expertise portable. — Nina Eisenberg
> [11:44](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=704s) never sleeps and never tells me off. — Nina Eisenberg
> [13:48](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=828s) AI let me build the thing. What it could not do was make it safe to trust at enterprise scale. The gap between 'I built it' and 'you can rely on it' is exactly where Robert comes in. — Nina Eisenberg
> [15:31](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=931s) Guess what? I'm Nina now. — Robert Greisemer
> [22:51](https://www.youtube.com/watch?v=tRu6xQ9_bAo&t=1371s) I turn into a pumpkin at 4:30 every day — Nina Eisenberg
## Mentioned Nina Eisenberg, Robert Greisemer, Coinbase, Claude, Claude Code, Casebase, Violet, Glean, Google Workspace, Okta, PagerDuty, Cloudflare, Podman, Docker Desktop, n8n, Confluence, The Good Place, Vim, ngrok, AngularJS, Vue.js, Vite, Next.js, ReactJS, Golang, SQLite
## Video description Robert Greisemer - Sr. SRE, Core AI Infrastructure, Coinbase Nina Eisenberg - AGC, Workplace Ethics & Investigations, Coinbase
What happens when the tool your enterprise team needs does not exist — and the person closest to the problem is not an engineer?
This talk will illustrate how a non-technical lawyer used AI coding tools to build an enterprise AI application after existing vendor options could not meet the team’s needs. The broader lesson is timely for AI4’s audience: as AI coding and agentic tools mature, domain experts can move from “requesting software” to building meaningful prototypes themselves, but enterprise deployment still requires security, reliability, privacy, and operational guardrails.
We will walk through the journey from a local “vibe-coded” MVP to an enterprise-ready application, including the practical controls needed to harden AI-assisted builds: authentication, RBAC, PII handling, observability, testing, and secure deployment patterns. Attendees will leave with a real-world collaboration model for pairing domain expertise with security and platform engineering so teams can move fast without creating unacceptable risk.
If you are trying to understand what AI-enabled builders mean for the future of enterprise software, this talk will show what is already possible — and what it takes to make it safe.
[Source](https://www.youtube.com/watch?v=tRu6xQ9_bAo)