DeanKelly751
- 88 skills
- 0 followers
- 9 hours ago last updated
- ▌ Adr Writer · deankelly751Capture architecture decisions as ADRs (Architecture Decision Records) using the standard Nygard template. Extracts context, decision, and alternatives from conversation, auto-numbers the file, and writes it to the project. Use when the user asks to record an architecture decision, create an ADR, or document a technical decision.
- ▌ Rfc Drafter · deankelly751Draft RFCs (Request for Comments) and technical proposals from conversation context. Structures ideas into a formal document with summary, motivation, proposal, alternatives, and open questions. Use when the user asks to write an RFC, draft a proposal, write a technical design doc, or formalise an idea.
- ▌ Jira Tickets · deankelly751Create JIRA tickets at any hierarchy level (Epic, Story, Task, Sub-task, Bug). Infers as much as possible from conversation context and recommends values; asks the user only for criteria it cannot determine. Use when the user asks to create a JIRA ticket, issue, story, task, bug, epic, or sub-task, or mentions filing/logging work in JIRA.
- ▌ Github Issues · deankelly751Create GitHub issues on any repo from a context document or conversation. Parses raw input, formats and improves issue titles and descriptions, infers labels and assignees, fills in missing fields, presents a review table, and creates issues on approval. Use when the user asks to create GitHub issues, file issues from a doc, bulk-create issues, or log work on a GitHub repo.
- ▌ Weekly Report · deankelly751Generate a weekly status report by aggregating Git commits, JIRA tickets, GitHub issues, and pull requests. Categorises work into completed, in-progress, and blockers. Use when the user asks for a status report, weekly summary, standup notes, or wants to summarise what they worked on.
- ▌ Review UX · deankelly751Evaluate user experience against Nielsen's heuristics. Covers user flows, error states, loading states, empty states, feedback, consistency, and information hierarchy.
- ▌ Review API · deankelly751Evaluate API design for consistency, correct HTTP semantics, error handling, pagination, versioning, security, and documentation quality. Covers REST and GraphQL.
- ▌ Review Database · deankelly751Review database schema design, index coverage, query patterns, migration safety, naming conventions, and data integrity constraints. Covers relational and document databases.
- ▌ Review Security · deankelly751Identify security vulnerabilities, auth weaknesses, injection risks, secrets exposure, and access control issues. Categorizes findings by OWASP Top 10. Produces a severity-rated security review report.
- ▌ Knowledge Ddd · deankelly751Domain-Driven Design: strategic patterns (bounded contexts, context mapping, ubiquitous language) and tactical patterns (aggregates, entities, value objects, domain events, repositories). Decision framework and anti-patterns. Use when modelling complex domains or defining service boundaries.
- ▌ Execution Poc Scaffold · deankelly751Step-by-step procedure to bootstrap a new PoC project. Covers hypothesis definition, assumption ranking, minimal tech stack selection, project structure, implementation, and findings documentation. Includes README and repo templates. Use when starting a new PoC or helping a user set one up.
- ▌ Execution Spike Design · deankelly751How to design and execute a technical spike. Covers framing the question, defining success criteria, timeboxing, choosing the narrowest experiment, documenting findings, and making a recommendation. Includes spike output template. Use when investigating unknowns, evaluating approaches, or answering technical questions with code.
- ▌ Knowledge Solid · deankelly751SOLID principles with practical decision frameworks for when to apply each. Covers Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion with real trade-offs. Use when designing classes, modules, or service boundaries.
- ▌ Execution GRAPHQL Schema · deankelly751Step-by-step procedure to design a GraphQL schema from a domain model. Covers type design, queries, mutations, error handling, pagination (connections pattern), subscriptions, and field-level auth. Includes a schema design checklist. Use when designing a new GraphQL API or extending an existing schema.
- ▌ Knowledge API Versioning · deankelly751API versioning strategies (URI path, query param, header, content negotiation) with trade-offs matrix. Breaking vs non-breaking changes, deprecation policies, Sunset headers, and migration strategies. Includes a decision framework for choosing a versioning approach. Use when planning API versioning or managing breaking changes.
- ▌ Execution Iac · deankelly751Infrastructure as Code workflows covering state management, module design, environment promotion, and drift detection. Tool-agnostic principles for managing infrastructure declaratively. Use when setting up IaC, designing module structure, or reviewing infrastructure code.
- ▌ Review Performance · deankelly751Identify performance issues including N+1 queries, missing caching, memory leaks, blocking operations, and unoptimized payloads. Checklist organized by layer (database, backend, frontend, network).
- ▌ Execution REST API Design · deankelly751Step-by-step procedure to design a REST API from requirements to OpenAPI spec. Covers resource identification, URI structure, HTTP methods, request/response design, error handling, pagination, filtering, and auth planning. Includes templates for common patterns. Use when designing a new REST API or extending an existing one.
- ▌ Knowledge REST Principles · deankelly751REST architectural constraints, resource modeling, URI design, HTTP method semantics, status code selection, content negotiation, and HATEOAS. Includes a decision framework for choosing between REST, RPC, and GraphQL. Use when designing or reviewing RESTful APIs, or deciding on an API style.
- ▌ Knowledge Concurrency · deankelly751Concurrency principles covering threads, async, locks, race conditions, and coordination patterns. Decision framework for choosing concurrency models. Use when designing concurrent systems, debugging race conditions, or choosing between sync and async approaches.
- ▌ Knowledge Poc Methodology · deankelly751PoC philosophy and decision framework: proving feasibility of riskiest assumptions, not building a mini-production system. Covers PoC vs prototype vs MVP vs pilot, success/failure criteria, risk-driven development, and when NOT to build a PoC. Use when planning, scoping, or evaluating a PoC.
- ▌ Review Architecture · deankelly751Evaluate architectural decisions, layer boundaries, dependency direction, coupling, cohesion, and scalability patterns. Produces a structured review report with severity-rated findings.
- ▌ Knowledge Fail Fast · deankelly751Fail-fast philosophy, error propagation strategy, and early validation principles. Covers preconditions, assertions, input validation boundaries, and how to make errors visible immediately. Use when designing error handling, validation layers, or debugging silent failures.
- ▌ Knowledge Mvp Strategy · deankelly751Minimum viable product scoping principles covering what to include, what to cut, and how to validate assumptions with minimal engineering effort. Use when scoping new features, defining project phases, or debating scope.
- ▌ Review Accessibility · deankelly751Audit for WCAG 2.1 AA compliance covering semantic HTML, ARIA, keyboard navigation, color contrast, screen readers, and focus management. Checklist organized by POUR principles.
- ▌ Execution Tdd Workflow · deankelly751Red-green-refactor TDD workflow with practical guidance. Covers when TDD helps most, when it's counterproductive, outside-in vs inside-out approaches, and the Transformation Priority Premise. Use when practising TDD or deciding whether TDD is appropriate for a task.
- ▌ Execution Unit Testing · deankelly751Step-by-step guide to writing effective unit tests. Covers Arrange-Act-Assert, naming conventions, isolation, mocking strategy, property-based testing, parameterized tests, and common anti-patterns. Use when writing, reviewing, or improving unit tests.
- ▌ Execution API Documentation · deankelly751How to write effective API documentation. Covers structure (overview, auth, quickstart, endpoint reference, errors, rate limits, changelog), OpenAPI best practices, example design, and common anti-patterns. Use when writing or reviewing API documentation.
- ▌ Execution Profiling · deankelly751Systematic performance profiling procedure covering CPU profiling, memory profiling, I/O analysis, and flame graphs. Use when investigating performance issues, establishing baselines, or validating optimization impact.
- ▌ Knowledge Owasp Top 10 · deankelly751OWASP Top 10 vulnerability categories with code-level examples and specific mitigations. Use when reviewing code for security issues, designing secure APIs, or advising on common web application vulnerabilities.
- ▌ Knowledge Test Strategy · deankelly751Test strategy principles: test pyramid, coverage strategy, test ROI, and testing economics. Decision frameworks for test investment, when to break the pyramid, and how to balance testing cost against bug cost. Use when deciding what to test, how much to test, or structuring a test suite.
- ▌ Knowledge Error Handling · deankelly751Error handling strategy covering error hierarchies, propagation patterns, recovery strategies, and consistent error responses. Use when designing error handling for services, choosing between exceptions and result types, or standardizing error responses.
- ▌ Knowledge Data Modeling · deankelly751Data modeling from conceptual to physical level. Covers entity relationship modeling, cardinality, inheritance strategies, and translating domain models to schemas. Use when starting new database designs or mapping domain concepts to tables.
- ▌ Knowledge Schema Design · deankelly751Relational database schema design principles covering normalization, denormalization trade-offs, naming conventions, constraints, and relationship modeling. Use when designing new schemas, reviewing database designs, or deciding on normalization level.
- ▌ Execution API Docs · deankelly751Write effective API reference documentation. Covers structure, examples, error documentation, and maintaining accuracy. Use when writing or reviewing API documentation.
- ▌ Execution Runbooks · deankelly751Create operational runbooks for incident response. Covers runbook structure, diagnostic steps, remediation procedures, and escalation paths. Use when writing runbooks for production systems or reviewing operational readiness.
- ▌ Execution Form Handling · deankelly751Design and implement forms with validation, error states, and accessible submission flows. Covers validation strategy, error messaging, multi-step forms, and optimistic submission. Use when building forms or reviewing form implementations.
- ▌ Knowledge Accessibility · deankelly751Web accessibility principles covering WCAG 2.1 AA, semantic HTML, ARIA, keyboard navigation, color contrast, and screen reader compatibility. Use when building UI components, reviewing frontend code for accessibility, or designing inclusive interfaces.
- ▌ Knowledge Prioritization · deankelly751Prioritization frameworks including RICE, ICE, MoSCoW, and opportunity cost thinking. Decision framework for choosing between competing priorities. Use when deciding what to build next, triaging backlogs, or justifying priority decisions.
- ▌ Knowledge Auth Patterns · deankelly751Authentication and authorization patterns with trade-offs, implementation guidance, and common mistakes. Covers sessions, JWTs, OAuth/OIDC, API keys, mTLS, RBAC, ABAC, and ReBAC. Use when designing auth systems, reviewing auth implementations, or choosing between auth approaches.
- ▌ Knowledge Guardrails · deankelly751AI safety guardrails covering input validation, output filtering, fallback strategies, and monitoring for AI systems. Use when designing safety mechanisms for AI-powered features or reviewing AI system reliability.
- ▌ Execution Background Jobs · deankelly751Design reliable background job processing systems. Covers job queue selection, idempotency, retry strategies, dead letter queues, and monitoring. Use when implementing async processing, task queues, or scheduled jobs.
- ▌ Execution Git Workflow · deankelly751Git branching strategy, PR workflow, commit conventions, and release process. Decision framework for choosing a workflow. Use when establishing team Git conventions, designing branch protection rules, or reviewing Git practices.
- ▌ Execution Evaluation Criteria · deankelly751How to define and score evaluation criteria for technology choices and PoC outcomes. Covers dimension identification, weighting, scoring rubrics, decision matrices, and common bias traps. Includes a reusable evaluation matrix template. Use when comparing technologies, scoring PoC results, or making build-vs-buy decisions.
- ▌ Execution Caching Strategy · deankelly751Choose and implement caching layers for backend systems. Covers cache placement, invalidation strategies, cache-aside pattern, TTL design, and cache stampede prevention. Use when adding caching to a system or debugging cache-related issues.
- ▌ Knowledge Service Patterns · deankelly751Backend service design patterns including Repository, Unit of Work, CQRS, Saga, and Service Layer. Decision framework for when each pattern applies. Use when designing backend services, choosing between patterns, or reviewing service architecture.
- ▌ Execution Cicd Pipeline · deankelly751Design a CI/CD pipeline from scratch. Step-by-step procedure covering stage design, artifact management, environment promotion, and failure handling. Use when setting up CI/CD for new projects or improving existing pipelines.
- ▌ Execution Feature Flags · deankelly751Implement feature flags safely covering flag types, targeting strategies, lifecycle management, and cleanup. Use when implementing progressive delivery, A/B testing, or decoupling deployment from release.
- ▌ Execution Load Testing · deankelly751Design and execute load tests covering test scenario design, load profiles, success criteria, and result analysis. Use when validating system capacity, preparing for traffic events, or establishing performance baselines.
- ▌ Knowledge Product Thinking · deankelly751Product thinking principles for engineers covering jobs-to-be-done, outcome over output, user empathy, and product-minded engineering. Use when making product trade-offs, prioritizing features, or ensuring engineering decisions serve user needs.
- ▌ Execution Threat Modeling · deankelly751Step-by-step STRIDE-based threat modeling workflow with scoring, prioritization, and a reusable template. Use when designing new systems, reviewing architecture for security risks, or when asked to perform a threat model on a component or system.
- ▌ Execution Contract Testing · deankelly751Consumer-driven contract testing workflow. Covers defining consumer expectations, generating contracts, verifying providers, the Pact pattern, and handling breaking changes. Use when testing service boundaries, API compatibility, or replacing heavyweight integration tests between services.
- ▌ Execution RAG Pipeline · deankelly751Build a retrieval-augmented generation pipeline. Step-by-step procedure covering document ingestion, chunking, embedding, retrieval, and generation with citations. Use when implementing RAG systems, improving retrieval quality, or designing knowledge-augmented AI features.
- ▌ Knowledge Agent Design · deankelly751AI agent architecture patterns covering tool use, planning, memory, and multi-agent coordination. Decision framework for agent design choices. Use when designing AI agent systems, choosing agent architectures, or reviewing agent implementations.
- ▌ Knowledge Event Driven · deankelly751Event-driven architecture: event sourcing, CQRS, messaging patterns (pub/sub, event bus, message queue), eventual consistency, sagas, choreography vs orchestration. Decision framework for sync vs async communication. Use when designing async systems, choosing communication patterns, or discussing event sourcing.
- ▌ Knowledge Component Design · deankelly751Component composition patterns, prop design, state boundaries, and reusability principles. Framework-agnostic patterns for building maintainable UI component trees. Use when designing component hierarchies, deciding component boundaries, or reviewing frontend architecture.
- ▌ Knowledge State Management · deankelly751State management decision framework covering local vs global state, state machines, derived state, and server state. Framework-agnostic principles for managing UI state complexity. Use when choosing state management approaches or debugging state-related bugs.
- ▌ Knowledge Networking · deankelly751Networking fundamentals for application developers covering DNS, load balancing, CDN, TLS, and service mesh. Decision framework for networking patterns. Use when designing distributed systems, troubleshooting connectivity, or choosing networking infrastructure.
- ▌ Knowledge Dry Kiss Yagni · deankelly751DRY, KISS, and YAGNI principles with trade-off frameworks for when they conflict. Covers when duplication is acceptable, when simplicity trumps abstraction, and when to defer features. Use when making design trade-off decisions or reviewing code for unnecessary complexity.
- ▌ Knowledge Secure By Design · deankelly751Security as an architectural property — principles, patterns, and decision frameworks for building systems that are secure by construction rather than by bolt-on controls. Use when designing systems, reviewing architecture, or making security trade-off decisions.
- ▌ Knowledge Indexing Strategy · deankelly751Database indexing principles covering index types, composite key design, covering indexes, and query plan analysis. Decision framework for when and what to index. Use when optimizing queries, designing indexes for new tables, or debugging slow queries.
- ▌ Knowledge Cicd Principles · deankelly751Continuous integration and continuous delivery philosophy. Covers CI/CD principles, pipeline stages, deployment strategies, and the path from commit to production. Use when designing CI/CD pipelines or reviewing deployment processes.
- ▌ Execution Responsive Layout · deankelly751Build responsive layouts using modern CSS (Grid, Flexbox, container queries). Step-by-step approach to mobile-first design, breakpoint strategy, and fluid typography. Use when implementing responsive UIs or converting designs to responsive code.
- ▌ Execution User Story Mapping · deankelly751Map user journeys into development slices using story mapping. Step-by-step procedure for creating a story map, identifying releases, and ensuring end-to-end user value in each slice. Use when planning features, defining sprints, or organizing backlogs.
- ▌ Knowledge Privacy By Design · deankelly751Privacy as an architectural property — data minimization, purpose limitation, consent management, GDPR/CCPA engineering implications, data classification, retention policies, and right to erasure patterns. Use when designing systems that handle PII, implementing data protection features, or reviewing data flows for privacy compliance.
- ▌ Execution Service Design · deankelly751Step-by-step procedure to design a new service from requirements. Covers boundary identification, interface design, architecture style selection, data modelling, error handling, observability, and testing strategy. Use when starting a new service, microservice, or significant module.
- ▌ Execution Migration Workflow · deankelly751Safe, reversible database schema migration workflow. Covers migration naming, zero-downtime changes, backward compatibility, and rollback strategy. Use when evolving database schemas in production systems.
- ▌ Execution Query Optimization · deankelly751Identify and fix slow database queries. Covers EXPLAIN analysis, common query anti-patterns, N+1 detection, and optimization techniques. Use when debugging slow queries or reviewing database access patterns.
- ▌ Review Production Readiness · deankelly751Comprehensive assessment of whether a system is ready for production traffic. Covers observability, reliability, security, operations, and scalability. The most thorough reviewer — use before launch or major releases.
- ▌ Execution Integration Testing · deankelly751Design and execute integration test suites. Covers scope definition, test containers, database testing, API testing, message queue testing, test data management, flakiness prevention, and speed optimization. Use when writing or reviewing integration tests.
- ▌ Knowledge Design Patterns · deankelly751GoF design patterns organised by intent (creational, structural, behavioral). One-line descriptions, when to use, when to avoid for the most commonly useful patterns. Anti-patterns around pattern overuse. Use when selecting or recommending design patterns for implementation.
- ▌ Knowledge Twelve Factor · deankelly751Twelve-Factor App methodology for building cloud-native services. Covers all 12 factors with modern interpretations and practical decision guidance. Use when designing services for cloud deployment, containerization, or reviewing application portability.
- ▌ Knowledge Caching Patterns · deankelly751Caching theory and patterns covering cache topologies, consistency models, eviction strategies, and invalidation approaches. Use when designing caching systems, choosing cache invalidation strategies, or debugging cache-related issues.
- ▌ Knowledge Release Strategies · deankelly751Deployment and release strategies covering blue-green, canary, rolling, feature flags, and progressive delivery. Decision framework for choosing the right strategy. Use when planning releases, designing deployment infrastructure, or choosing rollback mechanisms.
- ▌ Execution Decision Records · deankelly751Write ADRs (Architecture Decision Records) and RFCs (Requests for Comments). Covers when to use each format, templates, and maintenance. Use when documenting technical decisions or proposing significant changes.
- ▌ Execution Logging Strategy · deankelly751Structured logging implementation covering log levels, correlation IDs, context propagation, and what to log vs what not to log. Use when designing logging for services, standardizing log formats, or debugging log-related issues.
- ▌ Execution Metrics Alerting · deankelly751Define SLIs, SLOs, and set up meaningful alerting. Covers metric types, cardinality management, alert design, and burn-rate alerting. Use when implementing monitoring, designing dashboards, or setting up alerting for services.
- ▌ Knowledge Prompt Engineering · deankelly751Prompt engineering patterns covering system prompts, few-shot examples, chain-of-thought, structured output, and prompt testing. Use when writing prompts for AI systems, designing agent instructions, or optimizing LLM interactions.
- ▌ Knowledge Clean Architecture · deankelly751Clean Architecture principles: dependency rule, layers, boundaries, and screaming architecture. Decision framework for when to apply full Clean Architecture vs simplified layering. Use when discussing service structure, layer separation, or dependency direction.
- ▌ Knowledge Technical Writing · deankelly751Technical writing principles for engineers covering clarity, audience awareness, document structure, and progressive disclosure. Use when writing documentation, README files, technical guides, or reviewing documentation quality.
- ▌ Execution Containerization · deankelly751Dockerfile best practices, multi-stage builds, image optimization, and container security. Step-by-step procedure for containerizing services. Use when creating Dockerfiles, optimizing image size, or reviewing container configurations.
- ▌ Knowledge Defensive Programming · deankelly751Defensive programming principles including input validation, invariant protection, safe defaults, and trust boundaries. Covers the spectrum from paranoid to pragmatic defense. Use when hardening code against unexpected inputs, integrating with external systems, or designing public APIs.
- ▌ Knowledge Cloud Architecture · deankelly751Cloud architecture principles covering well-architected frameworks, multi-tier design, resilience patterns, and cost optimization. Provider-agnostic patterns for cloud-native systems. Use when designing cloud deployments, reviewing infrastructure architecture, or making cloud service decisions.
- ▌ Execution Distributed Tracing · deankelly751Instrument services for distributed tracing. Covers context propagation, span design, sampling strategies, and trace analysis. Use when adding tracing to services, debugging cross-service latency, or choosing tracing infrastructure.
- ▌ Knowledge Separation Of Concerns · deankelly751Separation of concerns, cohesion, and coupling principles. Covers how to draw boundaries between modules, identify misplaced responsibilities, and measure design quality through coupling metrics. Use when decomposing systems, designing module boundaries, or refactoring tangled code.
- ▌ Knowledge Hexagonal Architecture · deankelly751Hexagonal Architecture (Ports & Adapters): primary/secondary ports, driving/driven adapters, testability benefits, and relationship to Clean Architecture. Decision framework for when hexagonal is the right fit. Use when discussing service boundaries, adapter patterns, or testability.
- ▌ Knowledge Observability Pillars · deankelly751The three pillars of observability (logs, metrics, traces) and how they interrelate. Decision framework for what to instrument and at what level. Use when designing observability for new services or reviewing monitoring coverage.
- ▌ Knowledge Optimization Principles · deankelly751Performance optimization philosophy covering measurement-first approach, Amdahl's law, premature optimization avoidance, and systematic bottleneck identification. Use when deciding whether to optimize, where to optimize, or reviewing performance-related changes.