New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Protheus Spec-Driven Development

by totvs in totvs/engpro-advpl-tlpp-skills

Plans and builds Protheus AdvPL/TLPP features through Specify, Design, Tasks and Execute phases whose depth scales with the size of the change.

MITAuto-check passedDevelopment

Install Protheus Spec-Driven Development

skills CLI
$ npx skills add totvs/engpro-advpl-tlpp-skills --skill advpl-tlpp-sdd -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install totvs/engpro-advpl-tlpp-skills advpl-tlpp-sdd --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/totvs/engpro-advpl-tlpp-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/advpl-tlpp/advpl-tlpp-sdd .claude/skills/advpl-tlpp-sdd && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
advpl-tlpp-sdd
GitHub stars
143
Token cost
~3.6k tokens
SKILL.md length
1,278 words
Files
17 (incl. references)
Skills in repo
19
Repo updated
First seen
Licence
MIT

At a glance

Plans and builds Protheus AdvPL/TLPP features through Specify, Design, Tasks and Execute phases whose depth scales with the size of the change.

  • Works in 2 steps: Initialize project → PROJECT.md +… → For each feature → Specify → (Design) →…
  • Starting a new Protheus project or mapping an existing AdvPL/TLPP codebase
  • SKILL.md covers Auto-Sizing: The Core Principle, Project Structure, Workflow and Context Loading Strategy, plus 6 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

The skill's core idea is auto-sizing. A small change of up to 3 files takes quick mode and skips the pipeline. A medium feature with fewer than 10 tasks gets a brief spec, an inline design and implicit tasks. A large multi-component feature gets a full spec with requirement IDs, an architecture, a task breakdown with dependencies and per-task verification. A complex or ambiguous one adds a discussion of gray areas, research, a parallel plan and interactive user acceptance testing. Specify and Execute are always required, while Design and Tasks are skipped when the change is simple.

It also covers mapping an existing codebase, atomic tasks with verification criteria, atomic commits, requirement traceability, and persistent memory of decisions, blockers and ideas across sessions, with pause and resume support. Seventeen reference files hold the detail for each stage, including brownfield mapping, coding principles, session handoff, state management and validation. It is specific to AdvPL, TLPP and Protheus.

When your agent uses it

  • Starting a new Protheus project or mapping an existing AdvPL/TLPP codebase
  • Planning a feature with requirements, design and a task breakdown
  • Making a quick fix or entry point without the full pipeline
  • Pausing a piece of work and resuming it in a later session

Example prompts

  • “Map this Protheus codebase and document its modules, architecture and conventions.”
  • “Specify a new TLPP feature for purchase order approval and break it into atomic tasks.”
  • “Quick fix: an entry point returns the wrong value, find it and fix it with verification.”
  • “Pause the current work and write a handoff so I can resume tomorrow.”

Workflow steps

2 steps, taken from the first numbered list in SKILL.md.

  1. Initialize project → PROJECT.md + ROADMAP.md
  2. For each feature → Specify → (Design) → (Tasks) → Execute (auto-sized depth)

What it can do on your machine

Read from SKILL.md and the folder at commit 3908e4e. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Protheus Spec-Driven Development loads about 3.6k tokens when it runs, and up to ~22k if it reads all its reference files. Until then it costs about 221 tokens; SKILL.md has 1,278 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~221
When it runs · the whole SKILL.md, loaded when a task matches
~3.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~22k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from totvs/engpro-advpl-tlpp-skills at commit 3908e4e, republished under its MIT licence (© totvs). 1,278 words, ~3,581 tokens.

Download SKILL.mdSave it as .claude/skills/advpl-tlpp-sdd/SKILL.md (or your agent's skills folder). This skill also uses 16 other files; get the full folder from GitHub.
name
advpl-tlpp-sdd
description
Plan and implement Protheus projects/features with 4 adaptive phases — Specify, Design, Tasks, Execute. Auto-sizes depth based on complexity. Creates atomic tasks with verification criteria, atomic commits, requirement traceability, and persistent memory across sessions. Specific to AdvPL/TLPP + Protheus. Use when: (1) Starting new Protheus projects, (2) Working on existing codebases (map modules, architecture, conventions), (3) Planning features (requirements, design, task breakdown), (4) Implementing with verification and atomic commits, (5) Quick tasks (bug fixes, entry points, config), (6) Tracking decisions/blockers/ideas across sessions, (7) Pausing/resuming work. Triggers on: 'initialize project', 'map codebase', 'specify feature', 'discuss feature', 'design', 'tasks', 'implement', 'validate', 'verify work', 'quick fix', 'pause work', 'resume work'.
license
MIT
metadata.domain
Protheus
metadata.maintainer
ADVPL/TLPP Customizations
metadata.author
Kael Thornwick
metadata.version
1.1.0
metadata.category
Spec-Driven Development
metadata.based-on
tlc-spec-driven@2.0.0

Protheus Spec-Driven Development

Plan and implement Protheus projects with precision. Granular tasks. Clear dependencies. Right tools. Zero ceremony.

┌──────────┐   ┌──────────┐   ┌─────────┐   ┌─────────┐
│ SPECIFY  │ → │  DESIGN  │ → │  TASKS  │ → │ EXECUTE │
└──────────┘   └──────────┘   └─────────┘   └─────────┘
   required      optional*      optional*     required

* Agent auto-skips when scope does not justify

Auto-Sizing: The Core Principle

Complexity determines depth, not a fixed pipeline. Before starting any feature, assess scope and apply only what's needed:

ScopeWhatSpecifyDesignTasksExecute
Small≤3 files, one-sentenceQuick mode — skips pipeline entirely---
MediumClear feature, <10 tasksSpec (brief)Skip — inline designSkip — implicit tasksImplement + verify
LargeMulti-component featureFull spec + requirement IDsArchitecture + componentsFull breakdown + depsImplement + verify per task
ComplexAmbiguity, new domainFull spec + discuss gray areasResearch + architectureBreakdown + parallel planImplement + interactive UAT

Rules:

  • Specify and Execute are always required — you always need to know WHAT and to DO
  • Design is skipped when the change is straightforward (no architectural decisions, no new patterns)
  • Tasks is skipped when there are ≤3 obvious steps (they remain implicit in Execute)
  • Discuss is triggered inside Specify only when the agent detects gray areas that need user input
  • Interactive UAT is triggered inside Execute only for user-facing features with complex behavior
  • Quick mode is the express lane — for bug fixes, entry points, config, and small tweaks

Safety valve: Even when Tasks is skipped, Execute ALWAYS begins by listing atomic steps inline (see implement.md). If that listing reveals >5 steps or complex dependencies, STOP and create a formal tasks.md — the Tasks phase was wrongly skipped.

Project Structure

.specs/
├── project/
│   ├── PROJECT.md      # Vision & goals
│   ├── ROADMAP.md      # Features & milestones
│   └── STATE.md        # Memory: decisions, blockers, lessons, todos, deferred ideas
├── codebase/           # Brownfield analysis (existing projects)
│   ├── STACK.md
│   ├── ARCHITECTURE.md
│   ├── CONVENTIONS.md
│   ├── STRUCTURE.md
│   ├── TESTING.md
│   ├── INTEGRATIONS.md
│   └── CONCERNS.md
├── features/           # Feature specifications
│   └── [feature]/
│       ├── spec.md     # Requirements with traceable IDs
│       ├── context.md  # User decisions for gray areas (only when discuss is triggered)
│       ├── design.md   # Architecture & components (only for Large/Complex)
│       └── tasks.md    # Atomic tasks with verification (only for Large/Complex)
└── quick/              # Ad-hoc tasks (quick mode)
    └── NNN-slug/
        ├── TASK.md
        └── SUMMARY.md

Workflow

New project:

  1. Initialize project → PROJECT.md + ROADMAP.md
  2. For each feature → Specify → (Design) → (Tasks) → Execute (auto-sized depth)

Existing codebase:

  1. Map codebase → 7 brownfield docs
  2. Initialize project → PROJECT.md + ROADMAP.md
  3. For each feature → same adaptive workflow

Quick mode: Describe → Implement → Verify → Commit (for ≤3 files, one-sentence scope)

Context Loading Strategy

Base load (~15k tokens):

  • PROJECT.md (if it exists)
  • ROADMAP.md (when planning/working on features)
  • STATE.md (persistent memory)

On demand:

  • Codebase docs (when working on existing projects)
  • CONCERNS.md (when planning features that touch flagged areas, estimating risk, or modifying fragile components)
  • TESTING.md (when creating tasks or executing — drives test type and gate checks)
  • spec.md (when working on a specific feature)
  • context.md (when designing or implementing from user decisions)
  • design.md (when implementing from the design)
  • tasks.md (when executing tasks)

Never load simultaneously:

  • Multiple feature specs
  • Multiple architecture docs
  • Archived documents

Target: <40k tokens total context
**Reserve:** 160k+ tokens for work, reasoning, outputs
**Monitoring:** Display status when >40k (see context-limits.md)

Sub-Agent Delegation

Use sub-agents (the Task tool or equivalent) to keep the main context window lean and enable parallel execution. The orchestrator agent plans and coordinates; sub-agents do the heavy lifting.

When to delegate to a sub-agent:

ActivityDelegate?Why
Research (design phase, brownfield mapping)YesResearch output is large; only the summary matters in the main context
Implement a taskYesFile reads, edits, test output consume context; only the result matters
Parallel [P] tasksYes (one per task)The only way to actually run tasks in parallel
Sequential tasks without [P]YesKeeps implementation artifacts out of the main context
Planning, task creation, validation reportsNoRequire the full accumulated context to be coherent
Quick mode tasksNoToo small to justify the overhead

Context each sub-agent receives:

The orchestrator agent MUST provide each sub-agent with:

  • The specific task definition from tasks.md (What, Where, Depends on, Reuses, Done when, Tests, Gate)
  • Relevant coding principles and conventions (coding-principles.md, CONVENTIONS.md)
  • TESTING.md, if it exists (for gate check commands and test patterns)
  • Any spec/design context the task references

The sub-agent does NOT receive: definitions of other tasks, accumulated chat history, validation reports from other tasks, or STATE.md (unless the task explicitly references a decision/blocker).

What sub-agents return:

Each sub-agent reports:

  • Status: Complete | Blocked | Partial
  • Files changed: [list]
  • Gate check result: [pass/fail + test count]
  • SPEC_DEVIATION markers (if any)
  • Issues encountered (if any)

The orchestrator agent uses this to update status in tasks.md, traceability, and decide next steps.

Commands

Project level:

Trigger PatternReference
Initialize project, project setupproject-init.md
Create roadmap, plan featuresroadmap.md
Map codebase, analyze existing codebrownfield-mapping.md
Document concerns, find tech debt, what's riskyconcerns.md
Log decision, log blocker, add todostate-management.md
Pause work, end sessionsession-handoff.md
Resume work, continuesession-handoff.md

Feature level (auto-sized):

Trigger PatternReference
Specify feature, define requirementsspecify.md
Discuss feature, capture context, how should this workdiscuss.md
Feature design, architecturedesign.md
Break into tasks, create taskstasks.md
Implement task, build, executeimplement.md
Validate, verify, test, UATvalidate.md
Quick fix, quick task, small change, bug fixquick-mode.md

Skill Integrations

This skill coexists with other skills. Before specific tasks, check whether complementary skills are installed and prefer them when available.

Show full SKILL.md (527 more words)Show less
Diagrams → mermaid-studio

Whenever the workflow requires creating or updating a diagram, always check whether the mermaid-studio skill is installed before proceeding. If installed, delegate all diagram creation and rendering to it. Otherwise, proceed with inline mermaid blocks and recommend installation. Show the recommendation at most once per session.

Code Exploration → codenavi

Whenever the workflow requires exploring or discovering things in an existing repository (brownfield mapping, reuse analysis, pattern identification, dependency tracing), always check whether the codenavi skill is installed. If installed, delegate exploration to it. Otherwise, use the built-in analysis tools (see code-analysis.md).

Protheus Skills — Routing by Task

Before executing any Protheus task, check whether the corresponding skill is installed and prefer it:

TaskPreferred skill
Create new CRUD screen (legacy AxCadastro/Browse)mvc-generator
Create REST endpoint with @Get/@Post/... annotationstlpp-rest-endpoint-generator
Generate e2e screen tests via Webapp/SmartClienttir-test-generator
Review AdvPL/TLPP code (SonarQube compliance)code-review
Look up table structure from the dictionarydata-dictionary-lookup
Document functions/classes with ProtheusDOCdocumentation-writer
Migrate AdvPL code to modern TLPPadvpl-to-tlpp-migration
Create entry pointentry-point-designer
Refactor to reduce cognitive complexityrefactor-method-complexity-reduce
After ANY .prw/.tlpp code generationutf8-to-cp1252-conversion (mandatory)
After encoding conversion, before Gate Checkadvpl-tlpp-compile (mandatory)

Encoding rule: Every AdvPL/TLPP source file generated by AI is in UTF-8. The RDMake/AppServer compiler requires CP-1252. Conversion is mandatory before any compilation. Run utf8-to-cp1252-conversion after each code generation.

Compilation rule (Execute): Every task that generates or modifies .prw/.prg/.prx/.tlpp/.aph sources in the Execute phase MUST ask the user whether to compile, immediately after the encoding conversion (Step 4c) and before the Gate Check (Step 5). If the user confirms, run advpl-tlpp-compile; if the log returns [Info] All files compiled successfully. and [Info] Recompile finished. the compilation was successful. If there are errors, analyze the root cause, fix the source, and ask again — repeat until zero errors. After successful compilation, ask whether to open SmartClient WebApp in the browser and, if confirmed, open the URL http://<IP>:<PORT>/webapp (obtained from ~/.totvsls/servers.json) preferring the builtin browser tool (open_browser_page); if the tool is unavailable, use the native OS command (xdg-open on Linux, open on macOS, start "" <url> on Windows). See implement.md Step 4d.

Knowledge Verification Chain

When researching, designing, or making any technical decision, follow this chain in strict order. Never skip steps.

Step 1: Codebase → check existing code, conventions, and patterns in the project
Step 2: Project docs → README, docs/, inline comments, .specs/codebase/
Step 3: Web search → TDN (tdn.totvs.com), official docs, trusted sources
Step 4: Flag as uncertain → "I'm not sure about X — this is my reasoning, but verify"

Rules:

  • Never skip to Step 5 if Steps 1-4 are available
  • Step 5 is ALWAYS flagged as uncertain — never presented as fact
  • NEVER assume or fabricate. If you can't find the answer, say "I don't know" or "I couldn't find documentation for this". Inventing APIs, patterns, or behaviors causes cascading failures from design → tasks → implementation. Uncertainty is always preferable to fabrication.
  • Validate ALL external symbols (classes, methods, functions, namespaces) before writing calls — see symbol validation rules in AGENTS.md

Output Behavior

Model guidance: After completing lightweight tasks (validation, state updates, session handoff), naturally mention once that these tasks work well with faster/cheaper models. Record in STATE.md under Preferences so it doesn't repeat. For heavy tasks (brownfield mapping, complex design), briefly mention reasoning requirements before starting.

Be conversational, not robotic. Don't interrupt the workflow — add it as a natural closing note. Skip if the user seems experienced or has already acknowledged the tip.

Code Analysis

Use available tools with graceful degradation. See code-analysis.md.

© totvs, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 16 other files (references) in skills/advpl-tlpp/advpl-tlpp-sdd of totvs/engpro-advpl-tlpp-skills.

  • SKILL.md
  • references/brownfield-mapping.md
  • references/code-analysis.md
  • references/coding-principles.md
  • references/concerns.md
  • references/context-limits.md
  • references/design.md
  • references/discuss.md
  • references/implement.md
  • references/project-init.md
  • references/quick-mode.md
  • references/roadmap.md
  • references/session-handoff.md
  • references/specify.md
  • references/state-management.md
  • references/tasks.md
  • references/validate.md

Open the folder on GitHubat commit 3908e4e

Compare with similar skills

Protheus Spec-Driven Development next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Protheus Spec-Driven Development compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Protheus Spec-Driven Development this skilltotvs/engpro-advpl-tlpp-skills143—~3.6kAutomated safety check: PassMIT
Spec Driven Developzhu1090093659/spec_driven_develop987—~5.1kAutomated safety check: PassMIT
Conductor Track Managementwshobson/agents40k9 repos~420Automated safety check: PassMIT
Beads Task Memorygastownhall/beads28k—~1.2kAutomated safety check: PassMIT
CCPM Project Managementautomazeio/ccpm8.4k—~1.1kAutomated safety check: PassMIT
Review Spdzhu1090093659/spec_driven_develop987—~1.5kAutomated safety check: PassMIT

Similar skills

  • Spec Driven Develop

    zhu1090093659/spec_driven_develop

    Automates pre-development workflow for large-scale complex tasks.

    987 GitHub stars~5.1k tokensUpdated 2 mo ago
    DevelopmentAuto-check passed

  • Conductor Track Management

    wshobson/agents

    Use this skill when creating, managing, or working with Conductor tracks - the logical work units for features, bugs, and refactors. Applies to spec.md…

    40k GitHub starsUsed in 9 repos~420 tokens
    DevelopmentAuto-check passed

  • Beads Task Memory

    gastownhall/beads

    Tracks multi-session work with dependencies in the bd issue tracker so the agent can find ready tasks and recover its context after conversation compaction.

    28k GitHub stars~1.2k tokensUpdated today
    Agent WorkflowsAuto-check passed

  • CCPM Project Management

    automazeio/ccpm

    Runs a spec-driven workflow from PRD to epic to GitHub issues to parallel agents, with status, standup and blocked-work reports from bundled scripts.

    8.4k GitHub stars~1.1k tokensUpdated 6 mo ago
    Product & Project ManagementAuto-check passed

  • Review Spd

    zhu1090093659/spec_driven_develop

    Findings-first code review workflow for AI coding agents. An agent skill from zhu1090093659/spec_driven_develop.

    987 GitHub stars~1.5k tokensUpdated 2 mo ago
    DevelopmentAuto-check passed

  • Deep Discuss

    zhu1090093659/spec_driven_develop

    结构化深度讨论 Skill，用于与用户进行多轮问题分析和方案设计。当用户描述一个问题现象、故障表现、 技术困惑、方案选择困难，或明确说"讨论一下"、"帮我分析"、"我遇到一个问题"、"你觉得怎么样"、 "帮我想想"、"我在纠结"时，必须使用本 skill。当用户提供了一段描述（可能附带截图）并期望深入分析 而非直接给答案时，也应触发本…

    987 GitHub stars~418 tokensUpdated 2 mo ago
    DevelopmentAuto-check passed

More from totvs/engpro-advpl-tlpp-skills

All 19 skills in this repo

  • AdvPL UTF-8 to CP1252 Converter

    totvs/engpro-advpl-tlpp-skills

    Converts AdvPL and TLPP source files from UTF-8 to Windows-1252 in place after code generation, because the Protheus compiler accepts only CP1252 files.

    143 GitHub stars~2.6k tokensUpdated 4 days ago
    Auto-check passed

  • AdvPL/TLPP Compile in VS Code

    totvs/engpro-advpl-tlpp-skills

    Compiles AdvPL and TLPP sources from VS Code with the TOTVS Developer Studio extension, handling server setup, connection and compile result reporting.

    143 GitHub stars~3.7k tokensUpdated 4 days ago
    Auto-check passed

  • AdvPL and TLPP Code Review

    totvs/engpro-advpl-tlpp-skills

    Reviews AdvPL and TLPP source against SonarQube rules, ProtheusDOC requirements, security, performance and Protheus conventions, and reports findings by severity.

    143 GitHub stars~2.5k tokensUpdated 4 days ago
    Auto-check passed

  • Protheus Data Dictionary Lookup

    totvs/engpro-advpl-tlpp-skills

    Queries the TOTVS Protheus ERP data dictionary for tables, fields, indexes, parameters, triggers and lookups, including impact checks during refactoring.

    143 GitHub stars~1.5k tokensUpdated 4 days ago
    Auto-check passed

  • Protheus MVC Generator

    totvs/engpro-advpl-tlpp-skills

    Generates Protheus MVC screens in ADVPL/TLPP, with ModelDef, ViewDef, MenuDef and Browse functions for single-entity and master-detail layouts.

    143 GitHub stars~2.2k tokensUpdated 4 days ago
    Auto-check passed

  • Query Builder

    totvs/engpro-advpl-tlpp-skills

    Build optimized and safe SQL queries for Protheus tables. An agent skill from totvs/engpro-advpl-tlpp-skills.

    143 GitHub stars~4.7k tokensUpdated 4 days ago
    Auto-check passed

Categories

Questions about Protheus Spec-Driven Development

What does Protheus Spec-Driven Development do?

Plans and builds Protheus AdvPL/TLPP features through Specify, Design, Tasks and Execute phases whose depth scales with the size of the change. The skill's core idea is auto-sizing. A small change of up to 3 files takes quick mode and skips the pipeline.

When should I use Protheus Spec-Driven Development?

Protheus Spec-Driven Development fits situations like: starting a new Protheus project or mapping an existing AdvPL/TLPP codebase; planning a feature with requirements, design and a task breakdown; making a quick fix or entry point without the full pipeline; pausing a piece of work and resuming it in a later session.

How do I install Protheus Spec-Driven Development in Claude Code?

Run `npx skills add totvs/engpro-advpl-tlpp-skills --skill advpl-tlpp-sdd -a claude-code`. Or copy the skill folder (skills/advpl-tlpp/advpl-tlpp-sdd in totvs/engpro-advpl-tlpp-skills) into .claude/skills/advpl-tlpp-sdd in your project. Claude Code loads it when a task matches its description.

How do I install Protheus Spec-Driven Development in Codex?

Run `npx skills add totvs/engpro-advpl-tlpp-skills --skill advpl-tlpp-sdd -a codex`. Or copy the skill folder (skills/advpl-tlpp/advpl-tlpp-sdd in totvs/engpro-advpl-tlpp-skills) into .agents/skills/advpl-tlpp-sdd in your project. Codex loads it when a task matches its description.

Can I use Protheus Spec-Driven Development in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add totvs/engpro-advpl-tlpp-skills --skill advpl-tlpp-sdd -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/advpl-tlpp-sdd, .gemini/skills/advpl-tlpp-sdd, .github/skills/advpl-tlpp-sdd and .opencode/skills/advpl-tlpp-sdd in your project.

What does Protheus Spec-Driven Development need to run?

SKILL.md names no scripts, command-line tools or credentials: Protheus Spec-Driven Development is instructions for the agent only.

Does Protheus Spec-Driven Development access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Protheus Spec-Driven Development safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Protheus Spec-Driven Development use?

Protheus Spec-Driven Development is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Protheus Spec-Driven Development use?

About 3.6k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 19k tokens, read only when the agent opens those files.

What are the alternatives to Protheus Spec-Driven Development?

Skills that share tags, products or a category with Protheus Spec-Driven Development: Spec Driven Develop (zhu1090093659/spec_driven_develop, 987 stars), Conductor Track Management (wshobson/agents, 40k stars), Beads Task Memory (gastownhall/beads, 28k stars) and CCPM Project Management (automazeio/ccpm, 8.4k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Protheus Spec-Driven Development?

totvs (a GitHub organization) maintains it in totvs/engpro-advpl-tlpp-skills, which has 143 GitHub stars. The repository holds 19 skills in this directory. The repository was last updated on October 5, 2026.

Source: totvs/engpro-advpl-tlpp-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.