home / skills / duc01226 / easyplatform / skill-fix-logs

skill-fix-logs skill

safe

This skill fixes the agent's behavior by analyzing logs.txt and applying targeted improvements to logging, error handling, and diagnostics.

npx playbooks add skill duc01226/easyplatform --skill skill-fix-logs

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.5 KB

---
name: skill-fix-logs
description: "[Tooling & Meta] Fix the agent skill based on `logs.txt` file."
argument-hint: [prompt-or-path-to-skill]
infer: true
---

Think harder.
Use `skill-plan` and `claude-code` skills.
Use `docs-seeker` skills to search for documentation if needed.

## Your mission
Fix the agent skill based on the current `logs.txt` file (in the project root directory).

## Requirements
<user-prompt>$ARGUMENTS</user-prompt>

## Rules of Skill Fixing:
Base on the requirements:
- If you're given nothing, use `AskUserQuestion` tool for clarifications and `researcher` subagent to research about the topic.
- If you're given an URL, it's documentation page, use `Explorer` subagent to explore every internal link and report back to main agent, don't skip any link.
- If you receive a lot of URLs, use multiple `Explorer` subagents to explore them in parallel, then report back to main agent.
- If you receive a lot of files, use multiple `Explorer` subagents to explore them in parallel, then report back to main agent.
- If you're given a Github URL, use [`repomix`](https://repomix.com/guide/usage) command to summarize ([install it](https://repomix.com/guide/installation) if needed) and spawn multiple `Explorer` subagents to explore it in parallel, then report back to main agent.

## IMPORTANT Task Planning Notes

- Always plan and break many small todo tasks
- Always add a final review todo task to review the works done at the end to find any fix or enhancement needed

Overview

This skill inspects a project's logs.txt, diagnoses the root causes, and produces concrete fixes for the agent skill code and configuration. It coordinates planning, code generation, and documentation lookup using auxiliary skills to produce patches, tests, and a final review. The goal is a minimal, verifiable change set that resolves the errors shown in the logs. I act as the maintainer: plan tasks, run targeted research, and deliver actionable fixes.

How this skill works

I parse the logs.txt in the project root to extract error messages, stack traces, and failure patterns. I map each failure to small, prioritized tasks and use skill-plan to structure the work, claude-code to propose and generate code fixes, and docs-seeker or Explorer to fetch authoritative documentation when required. For GitHub-hosted code or many links/files I spawn parallel explorers and use repomix where recommended. I always include a final review task to verify fixes and suggest tests or CI adjustments.

When to use it

You have a logs.txt showing failing runs or crashes for an agent skill.
CI reports failing tests or runtime errors tied to the skill.
You receive an error report without clear reproduction steps and need a diagnosis-first plan.
You must triage many error sources (multiple files or URLs) in parallel.
Preparing a release and want a final pass to fix logged issues before shipping.

Best practices

Start by extracting distinct failures from logs and prioritize by impact and frequency.
Break work into many small TODOs and assign a final review task to verify fixes.
Use parallel explorers for multiple URLs or many files to reduce turnaround time.
Attach minimal, well-documented patches and include unit or integration tests where possible.
When encountering a GitHub repo, prefer repomix to summarize and coordinate parallel exploration.
Communicate assumptions and ask clarifying questions if arguments are missing.

Example use cases

Logs show NullReferenceException in C# skill: produce a targeted fix, unit test, and changelog entry.
CI failed on dependency resolution: update project files, pin versions, and add reproducible CI steps.
Multiple documentation links provided: use explorers in parallel to collect authoritative sources and synthesize fixes.
Large error dump with mixed failures: decompose into small tasks, fix highest-impact issues first, then iterate.

FAQ

What input do you need to start?

I require the logs.txt file in the project root. If no arguments are provided, I will ask clarifying questions before starting research.

How do you handle many links or files?

I spawn parallel Explorer subagents to traverse links or files concurrently. For GitHub repos I recommend using repomix to summarize and coordinate exploration.