<< All versions

Skill v1.0.0

currentLLM-judged scan95/100
emanuelrechsteiner/claude-rcode/backend-development
──Details
PublishedSeptember 28, 2026 at 05:02 AM
Content Hashsha256:b9a94fb657fb086b...
Git SHA7b1efaeb7145
──Files
Files (1 file, 5.8 KB)
SKILL.md5.8 KBactive
SKILL.md · 202 lines · 5.8 KB

version: "1.0.0" name: backend-development description: Firebase and state management specialist. Handles Firestore operations, Firebase Functions, Zustand stores, user-scoped security, and optimistic updates with rollback. Use when working with Firebase, Firestore, Cloud Functions, Zustand, state management, APIs, or backend logic. Triggers on "Firebase", "Firestore", "Zustand", "state management", "backend", "API", "Cloud Functions", "security rules", "database", "store", "backend bauen", "datenbank anbinden", "firestore regeln", "cloud function schreiben", "state management einrichten", "api endpunkt bauen", "speichern schlägt fehl". allowed-tools: Read, Edit, Write, Bash(npm:), Bash(node:), Bash(firebase:*), Grep, Glob

Backend Development Skill - Firebase & State Management

Memory-First Protocol (MANDATORY)

Before starting any task:

  1. Query Memory MCP for existing backend patterns: mcp__memory__search_nodes
  2. Load related store and API entities: mcp__memory__open_nodes

During task execution:

  • Create store/API entities: mcp__memory__create_entities with type "Store" or "API"
  • Add implementation details as observations: mcp__memory__add_observations
  • Link stores to components and functions: mcp__memory__create_relations

Core Competencies

1. Firebase Services Management

  • Firestore Operations: CRUD operations with proper user-scoped security
  • Firebase Functions: Serverless backend logic and data processing
  • Authentication Integration: User session and permission management
  • Security Rules: Data access control and validation

2. State Management Architecture

  • Zustand Stores: Domain-specific state management
  • Optimistic Updates: Immediate UI updates with rollback capability
  • Real-time Sync: Firestore subscriptions and live data updates
  • Error Handling: Comprehensive error states and recovery

Implementation Patterns

Zustand Store Structure

typescript
interface StoreState {
  // Data state
  items: Item[];
  selectedItem: Item | null;
  
  // UI state
  isLoading: boolean;
  error: string | null;
  
  // Actions
  loadItems: () => Promise<void>;
  createItem: (item: CreateItemData) => Promise<void>;
  updateItem: (id: string, updates: Partial<Item>) => Promise<void>;
  deleteItem: (id: string) => Promise<void>;
  setSelectedItem: (item: Item | null) => void;
  clearError: () => void;
}

Firebase Security Model

javascript
// User-scoped collections pattern
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{userId}/{collection}/{docId} {
      allow read, write: if request.auth != null && request.auth.uid == userId;
    }
  }
}

Firebase Functions Pattern

typescript
export const createItem = functions.https.onCall(async (data, context) => {
  // Authentication check
  if (!context.auth) {
    throw new functions.https.HttpsError('unauthenticated', 'User must be authenticated');
  }
  
  // Validation
  const itemData = validateItemData(data);
  
  // Create with user scoping
  const item = {
    ...itemData,
    id: generateId(),
    userId: context.auth.uid,
    createdAt: new Date(),
    updatedAt: new Date()
  };
  
  await admin.firestore()
    .collection('users')
    .doc(context.auth.uid)
    .collection('items')
    .doc(item.id)
    .set(item);
    
  return { success: true, item };
});

Error Handling Pattern

typescript
const handleAsyncOperation = async (operation: () => Promise<void>, errorMessage: string) => {
  try {
    set({ isLoading: true, error: null });
    await operation();
    set({ isLoading: false });
  } catch (error) {
    console.error(`${errorMessage}:`, error);
    set({ 
      isLoading: false, 
      error: error instanceof Error ? error.message : errorMessage 
    });
  }
};

Optimistic Updates Pattern

typescript
const updateItemOptimistically = async (id: string, updates: Partial<Item>) => {
  const { items } = get();
  const originalItem = items.find(item => item.id === id);
  
  // Optimistic update
  set({
    items: items.map(item => 
      item.id === id ? { ...item, ...updates } : item
    )
  });
  
  try {
    await updateItemInFirestore(id, updates);
  } catch (error) {
    // Rollback on error
    if (originalItem) {
      set({
        items: items.map(item => 
          item.id === id ? originalItem : item
        )
      });
    }
    throw error;
  }
};

Data Validation with Zod

typescript
import { z } from 'zod';
export const itemSchema = z.object({
  name: z.string().min(1, 'Name is required'),
  description: z.string().optional(),
  status: z.enum(['ACTIVE', 'INACTIVE', 'ARCHIVED']),
  metadata: z.object({
    tags: z.array(z.string()).optional(),
    priority: z.number().int().min(1).max(5).optional(),
  }).optional(),
});
export const itemUpdateSchema = itemSchema.partial();

Quality Standards

Code Quality

  • TypeScript Strict: Full type safety with proper interfaces
  • Error Handling: Comprehensive error states and user feedback
  • Performance: Efficient queries and minimal re-renders
  • Security: Proper data access control and validation

Testing Requirements

  • Unit Tests: Store actions and Firebase Functions
  • Integration Tests: End-to-end data flow validation
  • Security Tests: Access control and permission validation
  • Performance Tests: Query efficiency and load testing

Reporting Template

markdown
## Backend Implementation: [Feature Name]
 
### Components Delivered
-Zustand stores implemented
-Firebase Functions deployed
-Security rules updated
-Validation schemas created
 
### Data Integration
-Store-component integration tested
-Real-time subscriptions functional
-Optimistic updates working
-Error handling validated
 
### Security Validation
-User-scoped access verified
-Input validation tested
-Authentication flows working
-Permission checks functional
All versions