skills/autonomous-lessons/SKILL.md
# synaptic Autonomous Lessons Learned ## [LEARN] Entry from Mission smoke-test-001 ## Analysis of Mission Failure ### Identified Failures: 1. **SyntaxError**: The primary issue was the use of triple backticks (```) instead of triple quotes (`"""`) for the function definition and unit tests. 2. **Repetitive Errors**: Multiple iterations were required to correct the syntax error, indicating a lack of understanding or adherence to Python's syntax rules. ### Synthesized Non-Obvious Lessons: The m
npx skillsauth add shalin-rahman/Synapticity skills/autonomous-lessonsInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
""") for the function definition and unit tests.The model failed to understand that triple backticks are not valid in Python code. This suggests a fundamental misunderstanding of Python syntax and its documentation conventions.
InvalidSyntaxErrorThe updated constraint will be added to the skills/autonomous-lessons.md registry to enforce proper syntax usage in future missions.
# Technical Constraints
## InvalidSyntaxError
**Description:** The use of invalid syntax (e.g., triple backticks instead of triple quotes) will result in a SyntaxError.
**Impact:** This constraint ensures that all code snippets provided must adhere to Python's syntax rules, preventing such errors.
The mission failed due to a fundamental misunderstanding of Python syntax. By enforcing the InvalidSyntaxError constraint, we can prevent similar issues in future missions and ensure higher quality code.
SyntaxError due to the use of triple backticks (```) instead of triple quotes (""") in the Python code.""") instead of triple backticks (```). This will prevent syntax errors related to incorrect formatting.flake8 or pylint that checks for such issues during the development process.[LEARN], [REFINED], and [META] has been maintained to ensure clarity and professionalism in the documentation and analysis.# Technical Constraints
1. **Code Formatting and Syntax Validation**
- **Description:** Implement a rule in the code editor or IDE to enforce the use of triple quotes (`"""`) instead of triple backticks (``). This will prevent syntax errors related to incorrect formatting.
- **Implementation Steps:**
1. Configure the code editor to highlight or flag the use of triple backticks.
2. Integrate a static code analysis tool like `flake8` or `pylint` that checks for such issues during the development process.
The identified structural weakness in the synaptic framework's execution is primarily due to human oversight and lack of automated validation tools. By implementing a rule to enforce correct code formatting and integrating static code analysis, we can prevent such errors from recurring in the future.
tools
# Skill: Zero-Defect Software Engineering # Focus: Writing immortal, self-documenting, and resilient source code. ## Playbook Strategy: 1. **SOLID Foundations**: - **Single Responsibility**: Every class/function does ONE thing perfectly. - **Open/Closed**: Design for extension without modification. 2. **DRY (Don't Repeat Yourself)**: If logic appears twice, abstract it into a utility or base class. 3. **Defensive Programming**: - Validate every input. - Handle every exception specif
development
# Skill: TypeScript Clean Code (Staff Engineer) # Usage: Use for any TypeScript-based project to ensure enterprise-grade type safety and readability. ## Core Rules: - **Strict Typing:** Never use `any`. Use `unknown` with type guards if the type is truly uncertain. - **Interfaces vs Types:** Use `interface` for public APIs (extendability) and `type` for unions, intersections, and primitives. - **Functional Patterns:** Prioritize immutability. Use `readonly` for arrays and objects where possible
development
# Skill: Advanced Testing Strategies (TDD / BDD) # Usage: Use to enforce high code quality, prevent regressions, and ensure requirements are met implicitly. ## 🧪 The Testing Pyramid - **Unit Tests (70%)**: Fast, isolated tests for individual functions and classes. Mock all external dependencies. - **Integration Tests (20%)**: Test the interaction between several units or external systems (e.g., Database, APIs). - **End-to-End (E2E) Tests (10%)**: Slow, brittle tests that verify the system as a
development
# Skill: Technical Hand-off & Clarity # Focus: Professional documentation for human and machine consumption. ## Playbook Strategy: 1. **The "ReadMe First" Rule**: Use structured, hierarchical markdown. High-level summary first, deep-dive implementation second. 2. **Contextual Grounding**: Explain the "Why" and the "How" for every project. 3. **Semantic Clarity**: Use industry-standard terminology. Avoid jargon where simple language suffices. 4. **Machine-Readable Annotations**: Include clear co