Aakash GuptaI can’t believe we built an AI employee in 62 mins (Cursor, ChatGPT, Gibson)
CHAPTERS
- 0:00 – 3:41
Build plan + tech stack for an AI customer success “employee”
Harish outlines the end-to-end goal: an AI customer success agent that can diagnose risk and take actions without humans. He previews a 3-part build (dashboard → human-in-the-loop agent → autonomous agent) and the core stack: Gibson for the database, Cursor + Claude for coding, and CrewAI for agents, with o3-mini used for planning.
- •Objective: automate customer success insights and actions end-to-end
- •3 phases: dashboard → AI recommendations (HITL) → autonomous execution
- •Tools: Gibson (cloud DB), Cursor (IDE), Claude Sonnet (coding), CrewAI (agents), o3-mini (planning)
- 3:41 – 5:42
Using o3-mini to design the dashboard tabs and success metrics
They prompt o3-mini (reasoning mode) to propose a BI-style dashboard for a B2B e-commerce example. The model returns four core tabs focused on funnel, engagement, health/risk, and retention/churn—and explains why o3-mini is chosen for fast planning.
- •Prompting an LLM as a BI expert to define dashboard structure
- •Four-tab layout: funnel performance, engagement/usage, health/risk, retention/churn
- •Why o3-mini: fast, strong planning; Claude used later for coding
- 5:42 – 8:16
Translating dashboard needs into a data model (fields + sources)
Next, they use o3-mini to enumerate the data required to power each dashboard area. They refine the output to organize required fields by data source (HubSpot/CRM, Google Analytics, app DB), effectively creating a data definition document for schema design.
- •Identify data fields needed to power each dashboard view
- •Reformat outputs by data source (CRM, analytics, transactional DB)
- •Use the result as the blueprint for database schema
- 8:16 – 12:43
Creating a production-grade database in Gibson (web workflow)
Harish introduces Gibson as an AI-powered cloud database that can rapidly design, deploy, and manage scalable schemas. In the Gibson web UI, he initializes a project, chooses step-by-step modeling (since planning is already done), and explains how Gibson uses multiple LLM providers behind the scenes.
- •Gibson’s role: scalable backend + infra management for the app
- •Project initialization prompt sets context; step-by-step modeling chosen
- •Behind the scenes: Anthropic for code generation + OpenAI for planning/infra
- 12:43 – 17:23
Schema review, deployment, and instant CRUD APIs
Gibson generates the ER diagram and schema code, then deploys to cloud with dev and prod environments. Harish shows the auto-generated CRUD APIs, API keys, and direct DB connection string, highlighting how quickly a full backend is provisioned.
- •Outputs: ER diagram + code-based schema representation
- •One-click deploy provisions dev/prod environments
- •Instant CRUD API layer + connection string for direct DB access
- 17:23 – 23:39
Connecting Gibson to Cursor via MCP (database operations inside the IDE)
They move into Cursor and explain MCP (Model Context Protocol) as the bridge between the IDE and Gibson. Harish shows the available MCP tools (schema management, deploy, NL queries) and sets up the workflow to generate realistic test data via API-driven scripts.
- •MCP enables IDE-native interactions with external systems like Gibson
- •Capabilities: project/schema mgmt, deploy, natural language queries
- •Plan: create repeatable Python script to insert realistic test data
- 23:39 – 25:12
Generating and inserting realistic test data (Python + Faker)
Cursor generates a Python script and README for seeding the database, including installing Faker. They run the script locally and insert data through Gibson’s APIs, emphasizing Cursor’s control compared to pure prototyping tools.
- •Cursor generates script + run instructions (README)
- •Install dependencies (e.g., Faker) and run locally
- •Data inserted via Gibson APIs; focus on realism for dashboards
- 25:12 – 31:17
Vibe-coding the Next.js dashboard with Cursor Agent Mode
With data in place, they prompt Cursor to build a modern interactive dashboard using Next.js and shadcn/ui, powered by real Gibson APIs (no mock data). Harish explains Cursor modes (Ask vs Agent) and shows the finished 4-tab dashboard with charts and churn-risk table.
- •Prompt constraints: Next.js + shadcn/ui, real API data, no mocks
- •Cursor Agent Mode builds end-to-end and resolves issues automatically
- •Output: Customer Analytics, Funnel, Engagement/Retention, Churn Risk views
- 31:17 – 33:35
Why dashboards aren’t enough: moving from insights to actions
They discuss the gap between having charts and actually acting on them—typically a manual, inconsistent CS process. This motivates adding AI agents that interpret metrics, generate churn reasons, and recommend next steps for a human to approve.
- •Dashboards require human interpretation and follow-through
- •Inconsistency across CS reps motivates automation
- •Next step: agents to analyze + recommend actions (human-in-the-loop)
- 33:35 – 37:19
Adding an ‘agent actions’ table via Cursor → Gibson MCP
To store recommended actions, Harish updates the live database schema from within Cursor using the MCP connection. He creates an agent_actions table with fields like churn risk/reason, action, and message, then verifies it exists in Gibson.
- •Schema change done from IDE (no context switching) via MCP
- •New table captures CS recommendations and generated messages
- •Verification: table appears in Gibson after redeploy
- 37:19 – 40:27
CrewAI setup: multi-agent pipeline for churn detection and mitigation
Harish introduces CrewAI concepts (agents, tasks, and a ‘crew’) and walks through a prebuilt agent system. The pipeline includes a database query agent, churn analysis agent, mitigation agent, and ingestion agent that writes recommended actions back into the database.
- •CrewAI as orchestration framework (agents + tasks + tooling)
- •4-agent flow: query → analyze churn → propose mitigation → write back
- •Agents look for signals: low activity, declining usage, unresolved tickets, billing issues
- 40:27 – 44:31
Running the agents and populating recommendations in the dashboard
They execute the CrewAI workflow, which reads the Gibson schema/context and populates the previously empty Agent Actions view. The dashboard now shows prioritized risks, suggested actions (e.g., training, escalation), and draft email copy for humans to use.
- •Agents run in minutes and fill the actions table automatically
- •Dashboard now includes risk scores, churn reasons, and recommended steps
- •Human-in-the-loop: approve/copy/send recommendations rather than starting from scratch
- 44:31 – 53:20
Going autonomous: adding email sending + Jira ticket creation tools
Part three adds execution: an email agent (SendGrid) and a Jira ticket agent for product-issue churn reasons. Harish describes the required credentials/setup (ENV vars, Jira app/token) and updates the Crew to perform real-world actions automatically.
- •Two new execution agents: SendGrid email + Jira ticket creation
- •Workflow: mitigation results → send customer comms + file product issues
- •Operational requirements: accounts, API tokens, environment configuration
- 53:20 – 1:02:03
Results: Jira issues created and emails sent; broader ‘AI employees’ vision
They confirm the autonomous run by showing new Jira tickets with churn-risk labels and multiple emails delivered. The episode closes with ideas for other AI employees (SDR, exec assistant, recruiter) and Harish’s vision for Gibson as the production-grade database layer behind vibe-coded apps and agentic workflows.
- •Proof of execution: 3 Jira tickets created + 4 emails sent
- •Other AI employee patterns: SDRs, meeting prep, executive assistant, recruiting
- •Gibson’s thesis: production-ready DB + scaling/migrations so prototypes become real products
