← nyxcore-systems
5 min read

From Discussion to Decision: Unveiling AI-Powered Action Points and Cross-Project Insights

We just wrapped a major development sprint, rolling out interconnected features designed to transform raw discussions into actionable work items and detect patterns across projects, all powered by AI.

developmentfullstackprismanextjstrpcllmaiproduct-developmentaction-pointspersonastypescriptvector-search

In the fast-paced world of product development, brilliant ideas, critical feedback, and key insights often emerge from the most dynamic places: team discussions. Yet, far too often, these valuable nuggets can get lost, fragmented across different projects, or simply fail to translate into concrete action. We've been on a mission to solve this challenge, and I'm thrilled to share a major leap forward from our recent development session.

Our goal was ambitious: to build a robust bridge connecting discussions, insights, and actionable work items across all projects. This isn't just about task management; it's about creating an intelligent system that understands context, anticipates needs, and empowers teams to act decisively.

We've successfully completed a five-phase sprint, bringing to life three interconnected features: Action Points, Cross-Project Pattern Detection, and AI-Assisted Persona Management. The result? A system where npx tsc --noEmit passes with zero errors, 8 new files and 8 modified files are integrated, and our database schema is updated and ready for action.

The Core Vision: Connecting the Dots

Imagine a world where:

  • A critical action item is automatically identified from a long discussion thread.
  • A similar customer problem flagged in one project is instantly recognized as a pattern emerging in another.
  • Understanding your users is effortless, with AI helping you craft nuanced personas that truly reflect your audience.

This isn't just a dream anymore. These new features work in concert to achieve this vision, ensuring that valuable information doesn't just sit there, but actively drives product strategy and execution.

Under the Hood: A Phased Approach to Feature Delivery

Our development was structured into five distinct phases, each building upon the last to create a cohesive and powerful system.

Phase 1: Laying the Foundation – The ActionPoint Schema

Every robust feature begins with a solid data model. We introduced the ActionPoint model into our prisma/schema.prisma. This model is designed to be comprehensive, capturing everything from the title and description to its category, priority, status, and crucial links back to its sourceDiscussionId or sourceInsightId.

typescript
// Excerpt from prisma/schema.prisma
model ActionPoint {
  id               String    @id @default(cuid())
  tenantId         String
  userId           String
  projectId        String
  title            String
  description      String?
  category         String?
  priority         String?
  status           String    @default("open")
  sourceDiscussionId String?
  sourceInsightId  String?
  isAutoDetected   Boolean   @default(false)
  detectedInProjects String[]  // Projects where this pattern was also detected
  workflowId       String?

  // Relations...
}

This schema forms the backbone, allowing us to track actionable items with precision and link them directly to their origin. We also implemented Row Level Security (RLS) policies to ensure tenant isolation for these new action points.

Phase 2: Understanding Our Users – AI-Assisted Persona Management

Effective product development hinges on a deep understanding of your users. We've significantly enhanced our persona management capabilities:

  • Comprehensive CRUD: Full create, update, and delete procedures for personas via src/server/trpc/routers/personas.ts.
  • LLM-Powered Suggestions: A new src/server/services/persona-generator.ts leverages large language models (LLMs) to provide intelligent persona suggestions from free-text input, drastically speeding up the persona creation process. This utilizes our resolveWorkingProvider() pattern for flexible AI integration.
  • Intuitive UI: We built dedicated pages for listing personas (src/app/(dashboard)/dashboard/personas/page.tsx), a multi-phase AI-assisted creation flow (src/app/(dashboard)/dashboard/personas/new/page.tsx), and detailed view/edit pages (src/app/(dashboard)/dashboard/personas/[id]/page.tsx). Custom personas are editable, while built-in ones are read-only.
  • Sidebar Integration: "Personas" now has a prominent place in the dashboard sidebar.

Phase 3: Making Things Happen – Action Points CRUD

With the schema in place, we moved to enable the creation and management of action points themselves:

  • Robust tRPC Router: src/server/trpc/routers/action-points.ts now exposes 8 procedures, covering list, listAll, get, create, update, delete, and even createWorkflow.
  • Intelligent Extraction: A standout feature is src/server/services/action-point-extraction.ts. This LLM-powered service can analyze discussion messages and automatically identify potential action points, saving countless hours of manual review.
  • Project Integration: Action points are seamlessly integrated into individual project dashboards via a new "Actions" tab on src/app/(dashboard)/dashboard/projects/[id]/page.tsx, complete with CreateActionPointSheet and ExtractActionPointsSheet components.

Phase 4: Spotting Patterns, Eliminating Duplication – The Cross-Project Scanner

This is where the magic of interconnectedness truly shines. The src/server/services/cross-project-scanner.ts is a game-changer:

  • Vector Similarity Search: It performs vector similarity searches across all projects, identifying similar insights or discussions with a configurable threshold (currently 0.65).
  • Auto-Creation: When a significant similarity is found, it automatically creates ActionPoint records with isAutoDetected: true, linking them to the original insight and flagging other relevant projects.
  • De-duplication: Intelligent logic prevents duplicate auto-detected action points, ensuring a clean and focused view.
  • Strategic Triggers: This scanner is automatically triggered after the creation of high-severity insights (src/server/services/insight-persistence.ts) and after knowledge is exported from discussions (src/server/services/discussion-knowledge.ts), ensuring timely pattern detection.

Phase 5: The Grand Overview – Top-Level Action Points Dashboard

Finally, we brought everything together into a powerful, consolidated view:

  • Centralized Management: src/app/(dashboard)/dashboard/action-points/page.tsx provides a top-level dashboard to view all action points across all projects.
  • Grouped View & Filters: Action points are grouped by project, and users can filter by status, auto-detected status, priority, and category.
  • Workflow Creation: The page allows for easy status cycling and the creation of new workflows directly from action points.
  • Sidebar Access: "Action Points" now has its dedicated icon and entry in the dashboard sidebar, right after "Consolidation."

Challenges & Smooth Sailing

Sometimes, the best "pain log" is a short one! This sprint was a testament to effective planning and clear communication. We encountered no major issues, and both parallel development agents completed their tasks cleanly with zero overlapping file conflicts. A huge win was seeing npx tsc --noEmit pass on the very first attempt after all features were integrated. This indicates a high level of code quality and architectural foresight.

What's Next: Bringing It to Life

With the code deployed, our immediate next steps focus on rigorous quality assurance and activation:

  1. Apply RLS Policy: Secure the new action_points table by activating its Row Level Security policy: psql -f prisma/rls.sql.
  2. Manual QA: Persona Creation: Verify the AI-assisted persona creation flow, from free-text input to suggestion generation and final creation.
  3. Manual QA: Project-Specific Actions: Confirm manual action point creation, editing, and deletion within a project's "Actions" tab.
  4. Manual QA: AI Extraction: Test the LLM-powered extraction of action points from discussions, ensuring accurate categorization.
  5. Manual QA: Workflow Integration: Verify that workflows can be successfully created from action points.
  6. Manual QA: Top-Level View: Validate the consolidated action points dashboard, including grouping, filtering, and status updates.
  7. Test Cross-Project Scanner: Critically, we'll test the scanner by persisting a high-severity insight and verifying that auto-detected action points appear on other relevant projects.