council-of-logic_skill

Overview

This skill enforces mathematical first principles when you design, review, or optimise code and UI. It activates on mentions of optimisation, algorithm, performance, complexity, O(n), or during efficiency-focused code reviews. The council applies four canonical principles—Turing for algorithms, Von Neumann for architecture, Bezier for animations, and Shannon for information—to produce provably efficient, predictable, and compact implementations.

How this skill works

On trigger, the skill inspects code and design proposals for algorithmic complexity, concurrency and memory patterns, animation timing curves, and payload verbosity. It requires a short formal model (problem statement and targets) before implementation, then evaluates the proposed solution against each council rule. The output includes concrete refactors, complexity metrics, architecture recommendations, easing functions for UI, and compression suggestions.

When to use it

• When writing or reviewing algorithms with potential nested loops or heavy data processing
• When improving application performance or reducing latency and resource use
• When designing system workflows that must scale or run in parallel
• When implementing UI animations or micro-interactions that should feel natural
• When minimising payload sizes or optimising token/field usage in APIs

Best practices

• State the mathematical model before coding: time complexity target, architecture pattern, easing curve, compression strategy
• Reject O(n²) or worse: aim for O(n), O(n log n), or O(log n) with justification
• Design async/parallel hot paths; keep blocking work on cold paths or background workers
• Use physics-based easing (springs or cubic-bezier) for transitions; avoid linear timing
• Compress payloads and prompts by removing redundant fields and preferring implicit context when safe

Example use cases

• Refactor a nested-loop data join to a single-pass or hash-set approach to reach O(n)
• Rearchitect a synchronous request pipeline to async tasks with caching for hot-path performance
• Replace linear CSS transitions with spring or cubic-bezier curves for polished micro-interactions
• Trim API responses to essential fields and apply lightweight serialization to reduce tokens
• Review a proposed algorithm and produce the formal complexity target and verification checklist