skills.rest
web3br1
web3br1COMMUNITY
Explore all skills by this author →
GitHub

luminaris-implementer

Execute predefined plans and verify implementations against architecture contracts.

Updated Jun 18, 2026
Search Tags:#plan execution#code verification#architecture compliance#automated implementation#luminaris
One-click install
npx skills add https://github.com/web3br1/luminaristest --skill luminaris-implementer
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: luminaris-implementer
Source: https://github.com/web3br1/luminaristest/tree/main/.claude/skills/luminaris-implementer
Command: npx skills add https://github.com/web3br1/luminaristest --skill luminaris-implementer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill automates the implementation of Luminaris features by strictly following execution plans and adhering to architecture contracts, reducing manual errors and ensuring consistency.

Core Features & Use Cases

  • Plan Execution: Automatically executes each step in an execution plan.
  • Contract Adherence: Ensures all implementation steps comply with the architecture contract.
  • Verification: Executes checks and verifies the correctness of the implemented code.
  • Handoff: Generates a detailed implementation report for review by a reviewer.

Quick Start

Use the 'luminaris-implementer' skill to execute the provided plan for implementing a new feature in the Luminaris platform.

Frequently Asked Questions about luminaris-implementer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate plan execution for software features while ensuring architecture compliance?▼

Automated plan execution reads and implements predefined steps while verifying the code against architecture contracts, ensuring strict compliance and reducing manual implementation errors.

What is architecture contract verification in code implementation?▼

Architecture contract verification executes checks during implementation to validate that the generated code strictly adheres to predefined structural and design rules, outputting a detailed verification report.

How to generate an implementation report for code review after executing a development plan?▼

Generating an implementation report involves executing the plan steps, verifying the code against the architecture contract, and automatically producing detailed documentation for downstream reviewer handoff.

Can I use automated plan execution for complex software engineering tasks without manual intervention?▼

Automated plan execution handles complex software engineering tasks by strictly following execution plans and architecture contracts, requiring no manual intervention during the implementation phase itself.

What are the limitations of using strict architecture contracts for automated code implementation?▼

Strict architecture contracts limit automated code implementation to predefined boundaries, meaning any deviations or uncontracted architectural changes require updating the contract before execution can proceed successfully.

Does the luminaris-implementer skill support integration with external code verification tools?▼

The luminaris-implementer skill focuses on internal verification against architecture contracts, generating detailed reports for review, but does not explicitly list external tool integrations in its dependencies.

Related Skills

Explore More Software Engineering Skills→
jivebreaddevjivebreaddev

momus

Review work plans to identify context gaps and ambiguous requirements.

Community
Advanced
cdman28cdman28

phase-8-review

Analyze codebase quality, architecture consistency, and convention compliance across development phases.

Community
Advanced
0xHoneyJar0xHoneyJar
2

validating

Validate UI sprint components' physics and rigor compliance via Markdown reports.

Official
Intermediate
lystyplystyp

design-sparring-partner

Guide code reviews, architecture discussions, and implementation with design best practices.

Community
Advanced