Jeffallan

Sketches component layouts, trade-offs between tech choices, and architecture decisions in a format engineers can follow. Outputs diagrams and decision records, not hand-wavy sketches.

Scaffolds a C# REST API with Entity Framework Core, async request handling, and CQRS structure. Handles boilerplate so you focus on business logic.

Writes, debugs, and refactors C++20/23 code with templates, concepts, ranges, and SIMD. Catches memory bugs and suggests performance wins in high-performance systems code.

Scaffolds cloud-ready .NET apps with Entity Framework Core, JWT auth, and CQRS patterns. Handles minimal APIs, microservice plumbing, and AOT compilation gotchas.

Analyzes query plans and logs from PostgreSQL or MySQL, pinpoints the bottleneck (missing index, bad join, N+1), and writes the rewrite with before/after benchmarks.

Reviews your models, queries, and settings; spots the N+1s and missing indexes; suggests ORM tweaks and schema changes that cut load time without reshuffling code.

Scaffolds async endpoints, Pydantic models, JWT auth, SQLAlchemy queries, and WebSocket handlers — with boilerplate for a real API you can deploy immediately.

Runs a structured workshop that converts vague feature requests into detailed specs with user stories, acceptance criteria, and implementation checklists—organized so engineers have no ambiguity.

Answers Flutter and Dart questions: widget architecture, Riverpod or Bloc state management, navigation logic, and platform-specific code. Spots performance leaks and suggests fixes.

Handles ECS architecture, physics tuning, networking lag compensation, and frame-rate optimization—translating high-level game logic into production-ready Unity or Unreal code.

Takes your data model and builds a typed schema with resolvers, DataLoader patterns for batching, and federation directives—ready to wire up to a backend.

Writes idiomatic Rust, enforces ownership and lifetime correctness, designs trait hierarchies, structures async with tokio, and debugs memory and safety issues without hand-holding.

Reads your cluster state, pod logs, and resource metrics to diagnose crashes, misconfigurations, and resource leaks. Outputs corrected manifests and explains the fix.

Analyzes a tangled codebase, identifies service boundaries and dependencies, then produces a phased migration roadmap with API facades you can build incrementally without breaking production.

Configures Prometheus scrape jobs, wires Grafana dashboards, and defines alerting rules so you wake up to actual problems, not noise. Includes load-test guidance.

Generates boilerplate controllers, services, DTOs, and guards that fit NestJS conventions. Handles dependency injection plumbing and wires up validation and error handling.

Reviews a code snippet for OWASP Top 10 gaps, then flags the exact line, explains the risk, and gives a working patch with bcrypt, parameterized queries, or CORS config baked in.

Generates Laravel or Symfony code with strict typing, async patterns, and test coverage built in. Handles controllers, migrations, middleware, and PHPUnit all at once.

Reads your EXPLAIN output and suggests index changes, query rewrites, or config tweaks. Handles JSONB, partitioning, replication configs, and VACUUM tuning.

Generates fully type-annotated Python 3.11+ code, configures mypy in strict mode, and bundles pytest suites with fixtures and mocking. Lints with black and ruff.

Takes a pile of documents and designs a retrieval pipeline: chunking strategy, embeddings, vector store config, hybrid search, and reranking. Returns a tested, production-ready spec.

Writes .jsx/.tsx components, custom hooks, and state patterns for React 18+ and Next.js. Debugs rendering issues and migrates legacy code to modern patterns.

Pastes an error, stack trace, and relevant logs. Returns a hypothesis-driven breakdown of what failed and where, plus the next test to confirm the root cause.

Generates boilerplate configs, REST controllers, security flows, and JPA repositories for Spring Boot 3.x. Outputs runnable code with security and reactive patterns baked in.

Scaffolds standalone components, configures lazy-loaded routing, wires up NgRx state management, and applies RxJS patterns. Outputs code ready to commit.

Writes SwiftUI views, state management, and async handlers; spots concurrency bugs and thread-safety issues; structures the whole app so it scales without becoming a mess.

Reads a code file and generates unit, integration, or E2E tests with mocks, fixtures, and coverage analysis. Includes security and performance test cases.

Takes a decision, strategy, or proposal and systematically picks it apart—surfacing hidden assumptions, weak points, and second-order risks you'd catch in a pre-mortem.

Generates production-ready themes, plugins, Gutenberg blocks, and WooCommerce configurations with built-in security hardening, REST API endpoints, and performance tuning.

Sets up WebSocket infrastructure with Redis pub/sub, presence tracking, and room logic so multiple clients can send and receive messages instantly without polling.

Scans a diff or file for SQL injection, XSS, N+1 queries, naming problems, and architectural red flags. Returns a prioritized report with specific fixes, not generic notes.

Maps your system's weak points, designs a specific failure scenario, produces a runbook with rollback steps, and templates for capturing what broke and why.

Handles argument parsing, flags, subcommands, progress spinners, and shell completions so you write the business logic. Works across bash, zsh, and fish.

Maps your application onto AWS, Azure, or GCP; flags overspend and single points of failure; generates a migration roadmap and disaster-recovery playbook.

Reads your functions or API endpoints and generates docstrings, type hints, and OpenAPI specs that match your codebase style—then validates them against what the code actually does.

Writes and debugs .liquid theme files, custom Shopify apps, and Storefront API integrations. Handles OAuth, webhooks, and headless storefronts with production-ready code.

Scans code or infrastructure, flags vulnerabilities by severity, and gives you a ranked list of fixes with concrete steps for each — no security background required.

Writes DataFrame transformations, optimizes Spark SQL queries, and debugs cluster performance. Works with RDD pipelines and distributed data workloads without hand-holding on syntax.

Points at a repo or codebase and reconstructs its API surface, data flow, and dependencies as readable documentation—without asking the original author.

Helps write and troubleshoot firmware for microcontrollers—STM32, ESP32, FreeRTOS—covering interrupts, DMA, peripherals, power tuning, and real-time constraints.

Prepares training data, configures LoRA adapters, and sets hyperparameters so you can train a custom model on your own domain or use case without from-scratch infrastructure.

Helps design microservice layouts, optimize JPA queries, wire up Spring Security with OAuth2/JWT, and troubleshoot performance bottlenecks in enterprise Java stacks.

Designs experiment tracking, orchestration DAGs, feature stores, and model registries so your team can retrain, compare, and deploy models without manual handoffs or data science bottlenecks.

Scaffolds a complete web app—frontend, backend, database—with auth, input validation, parameterized queries, and output encoding wired together from the start, not bolted on after.

Defines SLOs for your service, calculates error budgets, designs incident response workflows, and generates monitoring configurations and automation scripts ready to deploy.

Analyzes your SQL and explains why it's slow, then rewrites it with better joins, indexes, or aggregations. Works with schema design and migration planning too.

Writes Terraform modules, manages state migrations, resolves provider conflicts, and walks through the setup across AWS, Azure, or GCP without requiring cloud CLI expertise.

Scaffolds a Nuxt 3 project with SSR, configures Pinia state, builds reusable Composition API components, and optimizes the Vite build—all in one go.

Writes idiomatic Go with goroutines, channels, and gRPC; handles concurrency patterns and error cases; profiles and optimizes for performance without boilerplate.

Guides you through resource modeling, versioning, pagination, and error handling. Produces an OpenAPI spec and a checklist so your API works before you code it.