Building a Cross-Project Consolidation Feature: From GitHub Integration to AI-Powered Pattern Recognition

As developers, we often work across multiple projects, accumulating insights, solutions, and hard-learned lessons that get scattered across repositories, documentation, and our own memory. Today, I'm sharing the journey of building a "Consolidation" feature—a system that aggregates development sessions across projects and uses AI to extract meaningful patterns from our collective coding experiences.

The Foundation: What We Built First

Before diving into the consolidation feature, we needed a solid pipeline. Here's what we accomplished:

Core Infrastructure

• Database Layer: Prisma schema with Project and BlogPost models, complete with tenant/user relationships
• GitHub Integration: A robust connector service (github-connector.ts) with BYOK (Bring Your Own Key) implementation
• Content Generation: AI-powered blog generation service that transforms raw development sessions into readable insights
• API Layer: Complete tRPC router handling CRUD operations, GitHub integration, and blog post management

User Experience

The UI includes four main pages:

• Projects list with sidebar navigation
• New project creation flow
• Detailed project view with tabbed interface
• Individual blog post viewer with markdown rendering

One particularly satisfying feature is the sequential blog post generation with live progress updates—no more wondering if your content is being processed.

Lessons Learned: The Technical Challenges

Every project teaches you something new. Here are the key insights from this build:

tRPC + React Query Gotchas

Working with tRPC and React Query v5, we discovered that calling refetch() on disabled queries is unreliable. The solution? Use state-driven enabled flags instead of trying to force refetches on dormant queries.

const { data, refetch } = trpc.projects.getAll.useQuery(
  undefined,
  { enabled: shouldFetch } // Better than calling refetch() manually
);

Batch Operations Reality Check

Initially, we planned batch mutations for generating multiple blog posts simultaneously. However, we quickly learned that batch operations provide no mid-process progress feedback. Sequential client-side calls proved much better for user experience—users can see exactly which posts are being generated and when.

Development Environment Quirks

Here's a workflow tip that saved us hours of debugging: when making Prisma schema changes, always stop the dev server FIRST, then delete the .next cache, and finally run prisma generate. The order matters more than you'd think.

TypeScript Inference Challenges

We hit a wall with TypeScript inference where ReturnType<typeof trpc...useQuery> would resolve data as {} instead of the actual type. The fix? Define explicit interfaces rather than relying on inference for complex tRPC queries.

The Next Challenge: Cross-Project Consolidation

Now comes the exciting part—building a consolidation feature that can:

1. Aggregate Insights: Collect letters and blog posts across multiple projects
2. Extract Patterns: Use AI to identify recurring successes, pain points, and solutions
3. Enable Discovery: Provide a searchable overview with intelligent filtering
4. Export Knowledge: Generate prompt hints and integrate with existing workflows

Technical Architecture Preview

The consolidation feature will require several new components:

// New Prisma model (conceptual)
model Consolidation {
  id        String   @id @default(cuid())
  title     String
  projects  Project[] // Many-to-many relationship
  patterns  Json     // AI-extracted insights
  createdAt DateTime @default(now())
  // ... additional fields
}

We're planning:

• A new tRPC router for consolidation operations
• An AI-powered pattern extraction service
• A searchable overview page with advanced filters
• Integration points with the existing workflow system

Why This Matters

This isn't just about building another feature—it's about creating a system that learns from our development patterns. Imagine being able to search across all your projects for "authentication issues" and instantly seeing not just the problems you've encountered, but the solutions that worked and the patterns that emerged.

The consolidation feature represents a shift from reactive documentation (writing about what happened) to proactive knowledge management (learning from what happened to improve what comes next).

Current State and What's Next

Our foundation is solid:

• Database contains real project data with 9+ generated blog posts
• All core functionality is committed and pushed to production
• Dependencies are locked and stable (react-markdown@^9, remark-gfm@^4, @tailwindcss/typography@^0.5)

The immediate roadmap includes:

1. Designing the consolidation data model
2. Building the AI pattern extraction service
3. Creating the searchable overview interface
4. Implementing export functionality
5. Integrating with existing workflows

Wrapping Up

Building developer tools is a unique challenge—you're simultaneously the creator and the user, which means every friction point you introduce, you'll feel personally. The consolidation feature represents our attempt to turn the scattered nature of multi-project development into a structured, searchable, and genuinely useful knowledge base.

Stay tuned for the next post where we'll dive deep into the AI pattern extraction service and show you how we're turning raw development sessions into actionable insights.

What patterns have you noticed in your own development work across projects? I'd love to hear about your experiences with cross-project knowledge management in the comments below.