Menü
This skill should be used when the user asks to "write common lisp", "CLOS", "ASDF", "defpackage", "defsystem", or works with Common Lisp, SBCL, or Coalton. Provides comprehensive Common Lisp ecosystem patterns and best practices.
Base templates for error escalation, decision criteria, and enforcement. Referenced by agents and commands to avoid duplication.
This skill should be used when the user asks to "use serena", "semantic search", "symbol analysis", "find references", "code navigation", or needs Serena MCP guidance. Provides Serena tool usage patterns and orchestration integration.
This skill should be used when working with C projects, "C11", "C17", "C23", "Makefile", "gcc", "clang", "valgrind", "getopt", or C language patterns. Provides comprehensive C23 and modern C patterns, memory management, and CLI development best practices.
Context7 MCP documentation retrieval patterns for up-to-date library and API references. Use this skill whenever current library docs, API signatures, version-specific behavior, or migration notes are needed.
This skill should be used when working with C++ projects, CMakeLists.txt, Ninja, clang-tidy, clang-format, GoogleTest, Catch2, or Modern C++ (C++20/23/26) language patterns. Provides comprehensive C++ ecosystem patterns and best practices.
Shared workflow phases and patterns for requirements definition commands. Use this skill when implementing /define or /define-full commands to ensure consistent workflow structure, agent delegation, and requirements documentation patterns.
| name | Common Lisp Ecosystem |
| description | This skill should be used when the user asks to "write common lisp", "CLOS", "ASDF", "defpackage", "defsystem", or works with Common Lisp, SBCL, or Coalton. Provides comprehensive Common Lisp ecosystem patterns and best practices. |
| version | 2.0.0 |
<common_lisp_fundamentals> Code and data share the same syntax (homoiconicity). Enables powerful macro systems for code transformation.
First-class named objects used for identifiers. Interned in packages, can have value, function, and property list. Functions can return multiple values using values, multiple-value-bind, multiple-value-list. Special variables with dynamic scope using defvar/defparameter. Convention: *earmuffs* for special variables. Common Lisp Object System - Generic functions and multiple dispatch Define a class with slots. Slot options: :initarg, :initform, :accessor, :reader, :writer, :type, :documentation. (defclass person () ((name :initarg :name :accessor person-name) (age :initarg :age :accessor person-age)) (:documentation "Represents a person.")) Define generic functions with multiple method implementations. (defgeneric greet (entity) (:documentation "Greet an entity."))
(defmethod greet ((p person))
(format t "Hello, ~a!~%" (person-name p)))
</example>
<decision_tree name="when_to_use">
<question>Do you need polymorphic behavior based on multiple types?</question>
<if_yes>Use defgeneric and defmethod for multiple dispatch</if_yes>
<if_no>Use regular functions for single implementation</if_no>
</decision_tree>
(defmethod greet :around ((p person))
(format t "[Start]~%")
(call-next-method)
(format t "[End]~%"))
</example>
;; In my-project/main.lisp:
(defpackage #:my-project/main
(:use #:cl)
(:import-from #:my-project/utils #:helper))
</example>
<decision_tree name="when_to_use">
<question>Do you want automatic dependency inference from package definitions?</question>
<if_yes>Use package-inferred-system for modern projects</if_yes>
<if_no>Use traditional defsystem with explicit component dependencies</if_no>
</decision_tree>
(sb-ext:save-lisp-and-die "my-app"
:toplevel #'main
:executable t
:compression t)
</example>
(let ((thread (sb-thread:make-thread
(lambda ()
(setf _result_ (heavy-computation)))
:name "worker")))
(sb-thread:join-thread thread))
;; Mutex
(defvar _lock_ (sb-thread:make-mutex))
(sb-thread:with-mutex (_lock_)
(critical-section))
</example>
(strlen "hello") ; => 5
</example>
;; Execute external programs
(sb-ext:run-program "/bin/ls" '("-l"))
;; Trigger garbage collection
(sb-ext:gc)
;; POSIX interface: sb-posix
;; Network sockets: sb-bsd-sockets
</example>
(declare safe-div (Integer -> Integer -> (Maybe Integer)))
(define (safe-div x y)
(if (== y 0)
None
(Some (/ x y)))))
</example>
(define-instance (Printable Integer)
(define (print-it x)
(into x))))
</example>
<common_patterns> Resource management with unwind-protect for cleanup. (defmacro with-open-socket ((var host port) &body body) `(let ((,var (make-socket ,host ,port))) (unwind-protect (progn ,@body) (close-socket ,var))))
Loop macro for iteration with collection, filtering, and accumulation. (loop for item in list for i from 0 when (evenp i) collect item into evens finally (return evens)) Common format directives: ~a (aesthetic), ~s (standard), ~d (decimal), ~f (float), ~% (newline), ~{~} (iteration), ~[~] (conditional). (format t "~a is ~d years old~%" name age) Document functions with docstrings explaining purpose and parameters. (defun my-function (arg) "Docstring describing the function. ARG is the argument description." (process arg))<standard_libraries> Conservative utility library. Provides essential utilities: when-let, if-let, hash-table-alist, ensure-list, mappings, and more. De facto standard for CL projects.
Comprehensive utility library (superset of alexandria). Provides additional utilities: string manipulation, sequences, types, binding macros, and more. Common Foreign Function Interface. Portable FFI for calling C libraries from Common Lisp. Preferred over implementation-specific FFI (e.g., sb-alien). (cffi:defcfun ("strlen" c-strlen) :int (str :string)) (c-strlen "hello") ; => 5
</example>
<package_sources>
<modern_tooling> Per-project dependency manager (like bundler/npm). Manages dependencies via qlfile, supports Quicklisp and Ultralisp distributions. <use_case>Install dependencies from qlfile</use_case> <use_case>Run commands with project dependencies</use_case> qlot install qlot exec ros run
Lisp implementation manager and script runner Install Lisp implementations or libraries Start REPL with specified implementation Build standalone executable ros install sbcl ros run ros build myapp.ros<context7_integration> Available Context7 documentation libraries for Common Lisp ecosystem.
Common Lisp Docs - General Common Lisp documentation /lisp-docs/lisp-docs.github.io 4.7 580 ASDF - Another System Definition Facility documentation /websites/asdf_common-lisp_dev 7.5 190 SBCL - Steel Bank Common Lisp documentation /sbcl/sbcl 8.0 86 CFFI - Common Foreign Function Interface documentation /websites/cffi_common-lisp_dev 7.5 198 FiveAM - Testing framework documentation /websites/fiveam_common-lisp_dev 7.5 164 Coalton - Statically typed functional programming documentation /coalton-lang/coalton 6.6 568 Use resolve-library-id then get-library-docs for latest documentation. ;; Get ASDF documentation mcp__plugin_claude-code-home-manager_context7__query-docs context7CompatibleLibraryID="/websites/asdf_common-lisp_dev" topic="defsystem"<best_practices>
Use *earmuffs* for special variables
Use +plus-signs+ for constants
Prefer functional style, minimize mutation
Provide restarts for recoverable situations
Document exported symbols
Use appropriate condition types, not just error
Use check-type for argument validation
Prefer ASDF package-inferred-system for new projects
Consider Qlot for per-project dependency management
Use Roswell for portable script execution
Use Alexandria and Serapeum as standard utility libraries
Use CFFI for foreign function calls (portable across implementations)
Consider Coalton for type-safe functional subsystems
</best_practices>
<anti_patterns> Global mutable state makes code harder to test and reason about. Pass state explicitly or use closures to encapsulate mutable state.
Using :use for packages other than :cl creates namespace pollution. Use :import-from or package-local-nicknames for clearer dependencies. Ignoring conditions loses error context and recovery opportunities. Handle conditions with handler-case or handler-bind, and provide appropriate restarts. Deeply nested code reduces readability and maintainability. Extract helper functions and use early returns to reduce nesting depth. Using eval in application code is slow and defeats compile-time optimization. Use macros for compile-time code generation or first-class functions for runtime dispatch. Custom reader macros make code harder to read for others. Use reader macros sparingly and document them clearly when necessary. Using the loop macro for all iteration, even when simpler constructs suffice. Use mapcar/remove-if/reduce for simple functional transforms. Consider iterate or series for complex iteration that loop handles poorly. Reserve loop for multi-clause iteration with collection and accumulation. Using simple error signaling without restarts, or catching and discarding conditions. Design APIs with restart-case to offer recovery strategies. Use handler-bind to handle conditions without unwinding the stack when possible. Use ASDF for all system definitions; never load files directly Provide restarts for recoverable error conditions Document all exported symbols with docstrings Target SBCL 2.5+ features; use modern ASDF 3.3+ defsystem patterns; never use legacy DEFINE-SYSTEM forms Use *earmuffs* for special variables, +plus-signs+ for constants Prefer :import-from over bare :use for clear dependencies Use check-type for argument validation at function boundaries Consider package-inferred-system for new projects Understand Lisp code requirements 1. Check ASDF system definition Workflow guidance Step completed 2. Review existing macros and patterns Workflow guidance Step completed 3. Identify CLOS class hierarchies Workflow guidance Step completed Write idiomatic Common Lisp code 1. Use appropriate abstraction level Workflow guidance Step completed 2. Follow condition system for errors Workflow guidance Step completed 3. Design reusable macros carefully Workflow guidance Step completed Verify Lisp code correctness 1. Load system with ASDF Workflow guidance Step completed 2. Run tests with appropriate framework Workflow guidance Step completed 3. Check for compilation warnings Workflow guidance Step completed<error_escalation inherits="core-patterns#error_escalation"> Style inconsistency Compilation warning or type error Macro expansion error Reader macro conflict </error_escalation>
Apply this skill when task keywords and domain match Use the canonical workflow and verify with project conventions<decision_tree name="skill_activation"> Does the task clearly match this skill domain? Use this skill workflow and constraints Use a more appropriate domain skill </decision_tree>
<related_agents> Locate code patterns and references in this skill domain Review implementation quality against this skill guidance Analyze code complexity and suggest refactoring improvements </related_agents>
Use ASDF for system definition Follow condition system for error handling Document macros with clear examples Overly complex macros without documentation Global state without clear lifecycle Reader macros without namespace isolation<related_skills> Navigate CLOS hierarchies, generic functions, and symbol definitions Access ASDF, SBCL, and Common Lisp library documentation Debug condition handling, macro expansion, and SBCL-specific issues Operational SBCL execution, debugger, profiling, and executable build workflows </related_skills>