Enforce Algorithmic Correctness in Code

lemmaly enforces an "algorithm-first" discipline: before writing any non-trivial loop, query, join, or recursion, it requires stating time/space complexity, the chosen data structure (with a one-phrase reason), and the algorithm family (e.g. linear scan, two-pointer, sliding window, hash join, BFS/DFS, DP, greedy) - in that order - before code is written. It is the gateway skill in a four-skill algorithm-discipline suite: lemmaly (prevention - think before coding), complexity-cuts (correction - a refactoring playbook for code that's already slow, OOMing, or timing out), invariant-guard (verification - for algorithms where the obvious version is subtly wrong, like binary search variants or in-place dedup, forcing a function contract and loop invariant), and mathguard (acceleration - for n >= 10^6, similarity search, or streaming analytics where classical algorithms hit their asymptotic floor and approximate/math-heavy techniques like Bloom filters or HyperLogLog are needed).

The "Iron Law": no non-trivial code without stated complexity, data structure, and algorithm family. A seven-step pre-write protocol requires stating the problem shape, input dimensions (realistic n), target complexity, data structures, algorithm family, and relevant edge cases (empty, singleton, all-equal, n=1, overflow, duplicates) before the code itself. It presumes repeated work inside loops is wrong until justified: I/O inside a loop, recomputing the same value, re-sorting inside a loop, linear scans (.find/.indexOf/.includes) inside a loop, and materializing intermediate collections just to iterate again are all flagged as needing either a fix or an explicit justifying comment.

// Without the protocol - ships O(n*m)
const active = users.filter((u) => !bannedIds.includes(u.id));

// With the protocol - O(n + m)
// time = O(n+m), space = O(m); structure: Set<string> for O(1) membership; family: linear scan with hashed lookup
const banned = new Set(bannedIds);
const active = users.filter((u) => !banned.has(u.id));

The upstream project also ships an optional deterministic CLI scanner covering 59 rules across 11 languages (JS/TS, Python, SQL, Java, C#, C++, Go, Rust, PHP, Ruby, Shell), each with a documented rationale and incorrect/correct example pair, flagging patterns like js-await-in-for-loop, py-mutable-default-arg, sql-update-no-where, and go-loop-var-capture at critical severity.

Use it when writing, editing, or reviewing any code involving loops, collections, lookups, joins, recursion, or graphs - and especially when auditing AI-generated code that "looks idiomatic" but might hide O(n^2) or N+1 behavior. Escalate to complexity-cuts instead when refactoring already-shipped slow code, to invariant-guard when the correctness risk is in a subtle algorithmic trap rather than raw complexity, and to mathguard when n is very large and classical algorithms have hit their lower bound. The skill explicitly warns against automatically cloning and running the upstream scanner's default branch, since that executes whatever code is currently on a third-party repository - if the scanner is wanted, pin to a reviewed release tag or commit, run it in a throwaway directory, and show the resolved commit hash before executing.

Input is a coding task involving iteration, lookup, or recursion over a collection. Output is a stated complexity/structure/algorithm-family declaration followed by code that matches that declaration, or a scanner report flagging specific anti-pattern rule violations by file and line if the optional CLI tool is run.

Works as a discipline layer applicable to any language; its optional companion CLI scanner (lemmaly.js scan/rules) supports JavaScript/TypeScript, Python, SQL, Java, C#, C++, Go, Rust, PHP, Ruby, and Shell/Bash.

Developers writing or reviewing code with loops, queries, or recursion - especially those reviewing AI-generated code - who want a forcing function against O(n^2)/N+1 defaults before code ships, rather than catching them after the fact.