Skip to content
Skills Library
Programming · Building & coding

backend-development

/backend-development

Implements backend code changes for Lambda handlers, service layers, and DynamoDB operations. Use when fixing code quality issues, adding features, or optimizing backend logic. Follows KISS/YAGNI/DRY principles with minimal, surgical changes.

Repository
konductor ↗
Licence
Apache-2.0
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Implements backend code changes for Lambda handlers, service layers, and DynamoDB operations. Use when fixing code quality issues, adding features, or optimizing backend logic. Follows KISS/YAGNI/DRY principles with minimal, surgical changes.

Original author description

Implements backend code changes for Lambda handlers, service layers, and DynamoDB operations. Use when fixing code quality issues, adding features, or optimizing backend logic. Follows KISS/YAGNI/DRY principles with minimal, surgical changes.

How it works

  1. Overview
  2. Usage
  3. Core Concepts
  4. Core Principles
  5. Implementation Standards
  6. Output Format
  7. Quality Gate
Original SKILL.md headings · 106 lines, 568 words
SKILL.md preview
---
name: backend-development
description: Implements backend code changes for Lambda handlers, service layers, and DynamoDB operations. Use when fixing code quality issues, adding features, or optimizing backend logic. Follows KISS/YAGNI/DRY principles with minimal, surgical changes.
version: 1.0.0
tags: [skill, backend, lambda, dynamodb, typescript, nodejs, implementation]
---

# Backend Development

## Overview

Implements backend changes with surgical precision — only the specific issue, nothing more. Covers Lambda handler patterns, service layer architecture, DynamoDB operations, type safety, error handling, and test improvements.

## Usage

Use this skill when:

- Fixing code quality issues from code review feedback
- Implementing new Lambda handlers or service methods
- Optimizing DynamoDB operations (atomicity, efficiency)
- Improving type safety (removing `any`, adding null checks)
- Adding or improving test coverage

## Core Concepts

### Architectural Layers

Handlers (entry point, delegates to facade) → Business Facade (orchestrates service calls) → Services (created via factory, contain business logic) → Repositories (data access through interfaces). No layer should bypass the one below it.

### KISS/YAGNI/DRY

Prefer simple, minimal solutions. Only add abstractions that solve a real, existing problem — not hypothetical future needs.

## Core Principles

**Always read the complete file before making changes.** Make minimal changes — only fix the specific issue. Follow established patterns in the codebase. Maintain backward compatibility.

**Prefer simple solutions over design patterns.** Only introduce patterns (Strategy, Observer) when they solve a real, existing problem — not hypothetical future needs. Call out over-engineering directly.

## Implementation Standards

### Handler Patterns

- Handlers delegate to a business facade — no direct business logic in handlers
- Services created via factory pattern — no direct instantiation
- Data access through repository interfaces — no direct database calls
- Use return values from store operations to avoid extra queries

### Type Safety

- No `any` types in production code (test mocks are the only exception)
- Use utility types: `Partial<T>`, `Pick<T, K>`, `Omit<T, K>`
- Validate before non-null assertions (`!`)
- Use `??` for null/undefined checks, not `||`

### DynamoDB Operations

- Atomic operations use transactions for multi-item updates
- Use conditional writes to prevent race conditions
- No extra queries — use return values from write operations
- Follow single-table design patterns (PK/SK)

### Error Handling

- Use specific error types, not generic `Error`
- Catch specific errors, not catch-all handlers
- Structured logging with correlation IDs and context
- Log diffs with structured fields showing before/after state

### Testing

- Create shared fixture factories for test data — not inline objects
- Use `toContainEqual` for order-independent assertions
- Add tests for new code before marking complete
- Test edge cases: null values, empty arrays, boundary conditions

## Output Format

For each change, provide:

1. File path
2. Issue (with line numbers)
3. Exact code changes
4. How to verify the fix
5. What else might be affected

## Quality Gate

**CRITICAL (must fix before done):**

- TypeScript compilation fails
- Tests fail
- Breaking change introduced without migration path
- Direct database connection bypassing repository layer
- Race condition introduced (non-atomic multi-item update)

**IMPORTANT (should fix):**

- `any` type used in production code
- Missing null check before non-null assertion
- Extra query when return value from write operation could be used
- Catch-all error handler masking specific errors
- Test data constructed inline instead of using fixture factory

**SUGGESTION:**

- Could extract repeated logic into shared utility
- Could add structured log fields for better observability
- Could strengthen test assertions to check actual values

Present findings as: CRITICAL → IMPORTANT → SUGGESTION. Ask: "Fix these issues? [y/n]" — unless `scope_confirmed` is true, in which case report all the findings and leave fixing to the caller, without asking.

Versions

RepositoryScoreLicence
This page · aws-solutions/konductor100Apache-2.0
rommapp/romm100AGPL-3.0
aAAaqwq/AGI-Super-Team100MIT
MoizIbnYousaf/ai-agent-skills100MIT

Database snapshot: 13.11.2026 · package version a5985e459df9 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 85backend-code-quality-review
    Use when reviewing backend code for SOLID/DRY/KISS/YAGNI violations, naming, cohesion, and coupling. Triggers when source files in a backend stack (Java, Kotlin, Python, Node/TS, Go) are in scope. Skip for infrastructure code (Terraform, K8s manifests).
  • 86engineering-principles
    Core code-quality rules — YAGNI, KISS, DRY with judgment, small single-purpose units, clear naming, minimal-scope diffs. Use whenever writing, refactoring, or reviewing code in this repo.
  • 95clean-code
    Clean Code principles (DRY, KISS, YAGNI), naming, function design and readability. Use when code is hard to read, with long methods, unclear names, duplication or deep nesting. For how responsibilities are split across classes and which way dependencies point, use solid-principles instead.
  • 100code-quality
    Audit a repository, some paths or the changed files for DRY, KISS, YAGNI and SOLID problems with parallel analyzer agents and a refuting verifier, write a report of file:line findings, and fix the findings the user picks on a branch, test first. Use when the user asks for a…
  • 100react-principles
    Principles and practices for writing React: SOLID, DRY/KISS/YAGNI, Hooks, state, effects, TypeScript and testing. Use when creating, refactoring or reviewing React components, Hooks, props or frontend structure.
  • 100code-quality-principles
    Applies KISS, YAGNI, and SOLID principles for clean code with reduced complexity. Use when refactoring or reviewing code for over-engineering.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.