leg-implement-target-nextjs

Implement or incrementally complete a legacy-modernization module in a target Next.js application from a canonical curated feature requirement package and its linked target implementation specification. Use when a reviewed mockup supplies the approved visual UI while curated requirements supply every backend, Oracle, validation, operation, persistence, transaction, error, and security behavior; supports POC generation with explicit known gaps without silently inventing missing behavior.

Quality

85%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Low

Low-risk findings worth noting

Quality

Content

88%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The body is an exceptionally concrete, well-sequenced procedural contract: every step carries executable specifics (paths, commands, dispositions, verification checklists) with explicit validation checkpoints and failure handling for destructive operations. Its only real costs are repetition of guardrails across sections and heavy inline detail that could partially move to reference files.

Dimension	Reasoning	Score
Conciseness	The body is dense with project-specific rules and never explains concepts Claude already knows, but guardrails repeat across sections (child-only mutation rules in steps 5, 8, and 9; the Yes/No-vs-Y/N warning in both steps 4 and 8), so it could be tightened — matching anchor 4 rather than 5.	4 / 5
Actionability	Guidance is fully concrete: exact file paths for the requirement package and manifest, a complete executable validator command with flags, enumerated dispositions (READY_IMPLEMENT through BLOCKED), a defined error-boundary shape (code, message, optional constraint and target), and an explicit verification checklist — copy-paste-ready for an instruction-only skill, matching anchor 5.	5 / 5
Workflow Clarity	Ten clearly sequenced steps with explicit validation checkpoints (pre-implementation curation validator with a defined failure rule, a lint→typecheck→test→build sequence, browser verification) and honest-reporting guards ("Never claim browser, database, or production readiness for checks that were not run"), including feedback handling for destructive operations — matching anchor 5.	5 / 5
Progressive Disclosure	One clearly signaled, one-level-deep reference (references/authority-and-conformance.md, which exists) and a well-sectioned body, but at 285 lines substantial inline content — the 15-item test checklist and the detailed adapter/translator specifications — could be split into reference files, so placement is good but not fully split, matching anchor 4 rather than 5.	4 / 5
	Total	18 / 20 Passed

Description

73%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description is explicit, third-person, and clearly establishes a well-bounded niche with an explicit "Use when" clause, so conflict risk is minimal. Its main weaknesses are limited action variety — the behavior enumeration conveys scope rather than a list of concrete capabilities — and trigger phrasing that leans on internal pipeline jargon rather than natural user language.

Suggestions

Lead with a short list of distinct concrete actions (e.g., "Implements module code, builds the UI-to-Oracle adapter, generates the server-side error translator, and records a coverage manifest") instead of one broad action plus an enumeration of governed behaviors.

Add natural trigger phrases to the "Use when" clause that a user would actually say, such as "implement this feature in the Next.js app", "continue the implementation", or "validate the implemented module", alongside the current condition-based wording.

Reduce reliance on internal jargon ("canonical curated feature requirement package", "governed package") in favor of terms users of the pipeline would naturally use when requesting this skill.

Dimension	Reasoning	Score
Specificity	The description names the domain and two concrete actions ("Implement or incrementally complete a legacy-modernization module in a target Next.js application", "supports POC generation with explicit known gaps"), but the long enumeration of behaviors ("backend, Oracle, validation, operation, persistence, transaction, error, and security behavior") describes scope rather than distinct actions, so coverage is not comprehensive as anchor 4 requires.	3 / 5
Completeness	Both "what" (implement or incrementally complete a module from a curated requirement package and linked specification) and "when" ("Use when a reviewed mockup supplies the approved visual UI while curated requirements supply every backend... behavior") are explicitly present, but the when-clause is conditional-descriptive rather than concrete user trigger phrases, matching anchor 4 rather than 5.	4 / 5
Trigger Term Quality	Good keyword coverage including natural terms a user in this domain would say ("Implement", "Next.js", "legacy-modernization", "Oracle", "mockup", "POC", "module"), but internal jargon like "canonical curated feature requirement package" is not a user utterance and no synonyms or file extensions are covered, so it falls short of anchor 5.	4 / 5
Distinctiveness Conflict Risk	A clear niche (legacy modernization into a target Next.js app driven by curated requirement packages and Oracle contracts) with distinct triggers and essentially no overlap risk with generic skills, matching anchor 5.	5 / 5
	Total	16 / 20 Passed

Validation

100%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: sibendu/ai_tessl
Path: .codex/skills/leg-implement-target-nextjs/SKILL.md
Commit: a49a39f

Reviewed: 4 hours ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.