Typescript Strict Mode Enforcer
Transform TypeScript codebases to enforce strict mode type safety
What You Can Do
This skill scans your TypeScript codebase for type safety violations and systematically remediates them. You can automatically remove implicit any types, add comprehensive type annotations to functions and variables, configure strict mode compiler options in tsconfig.json, and receive actionable refactoring guidance with concrete code examples. It's designed for migrating existing projects to strict mode or enforcing strict practices before production deployment.
Features
Identifies implicit `any` types, missing annotations, and unsafe patterns
Replaces unsafe `any` usage with proper inferred or explicit types
Adds complete type signatures to parameters, return types, and variable declarations
Validates and updates compiler options for strict mode, strictNullChecks, noImplicitAny, and related settings
Scans entire codebase to ensure consistent type coverage and safety
Provides specific code examples and before/after transformations for implementation
Ensures third-party type definitions integrate properly without type gaps
Example Output
Example 1: Implicit any Detection and Fix
// Before
function processData(input) {
return input.value;
}
// After
function processData(input: { value: string }): string {
return input.value;
}
Example 2: tsconfig.json Strict Mode Configuration
{
"compilerOptions": {
"strict": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"noImplicitAny": true,
"noImplicitThis": true
}
}
Example 3: Type Safety Report
Violations found: 23 implicit any types, 15 unannotated parameters, 8 unsafe null access patterns. Refactoring recommendations with code samples for each category.
What's Included
- SKILL.md instruction file with detailed configuration guidelines:
- TypeScript strict mode configuration template:
- Type safety violation checklist:
- tsconfig.json reference with compiler option explanations:
- Before/after refactoring examples for common patterns:
Who It's For
- Backend TypeScript engineers migrating projects to strict mode
- Full-stack developers hardening type safety in production codebases
- Tech leads enforcing code quality standards across teams
- DevOps engineers automating type safety validation in CI/CD pipelines
- Software architects planning type-safe architecture transitions
Best For
- Migrating existing TypeScript projects to strict mode for the first time
- Refactoring legacy codebases with widespread `any` type usage
- Pre-production type safety hardening and validation
- Enforcing team-wide strict mode standards during onboarding
- Eliminating type-related runtime errors in critical application paths
You might also like
Rapidly analyze firmware logs and diagnose hardware issues that cause device failures, connectivity problems, and performance degradation. You'll identify root causes from stack traces, crash dumps, and sensor data, then generate specific optimization recommendations. This skill transforms raw device logs into actionable debugging plans that reduce time-to-resolution from hours to minutes.
Analyze chemical processes systematically to identify hazards, assess risks, and generate safety recommendations. You can perform HAZOP analyses, evaluate compliance with industry standards, conduct root-cause analysis of incidents, and develop emergency response procedures. The skill guides you through structured safety reviews that reduce the likelihood of accidents and regulatory violations.
When a user uploads a file to Claude, you can intelligently detect its type and read it using the appropriate method. Instead of blindly running cat on binary files or loading massive CSVs into context, this skill routes each file type to the right tool, reading only what's needed to answer the user's question. You'll extract text from PDFs, parse structured data from CSVs and JSON, process images, and decompress archives—all without wasting context or producing garbage output.
by seifbenayed
You'll develop systematic approaches to injectable formulation design, from API selection through sterilization strategy. Claude helps you troubleshoot failed batches by analyzing root causes, recommends regulatory pathways (505(b)(2), ANDA, NDA), and provides science-backed solutions for stability, compatibility, and manufacturability challenges.
This skill helps you systematically assess integration needs across your systems, design architecture patterns that scale with your organization, and identify technical and operational risks before implementation. You'll receive architecture recommendations aligned to your business constraints, clear integration roadmaps, and risk mitigation strategies that reduce deployment surprises. Get structured decision records suitable for architecture review boards and engineering teams.
You can conduct comprehensive hazard analyses for chemical processes using industry-standard methodologies like HAZOP and LOPA. The skill helps you assess risks quantitatively, identify control gaps, design engineered safeguards, and generate formal documentation for regulatory compliance and process safety management.
Claude analyzes your code diffs and generates standardized commit messages that follow the Conventional Commits specification. The skill automatically determines the correct commit type, scope, and description based on the changes you've made, ensuring your messages are parseable by automation tools while remaining human-readable for code reviewers.
Query your local Screenpipe instance to retrieve screen recordings, audio transcriptions, UI element accessibility trees, keyboard/mouse input logs, and productivity analytics. You can search by keywords, filter by content type (audio, OCR, accessibility, input), set time ranges, and extract structured data about your applications, meetings, and work sessions without sending data to external servers.
by az9713