[BUG] # Bug Report: Excessive Token/Time Consumption with Third-Party Skills
Resolved 💬 3 comments Opened Jan 28, 2026 by augustose Closed Feb 1, 2026
Preflight Checklist
- [x] I have searched existing issues and this hasn't been reported yet
- [x] This is a single bug report (please file separate reports for different bugs)
- [x] I am using the latest version of Claude Code
What's Wrong?
Summary
A simple Rust CLI project (~300 lines of code) that should have taken 20-30 minutes consumed an entire day due to Claude entering unnecessary subagent loops triggered by the "superpowers" plugin.
Environment
- Claude Code CLI
- Plugin:
superpowers@superpowers-marketplacev4.0.3 - Skills involved:
subagent-driven-development,brainstorming,writing-plans
What Happened
- Simple task: Create a Markdown terminal renderer CLI in Rust (6 source files, ~300 lines total)
- Expected behavior: Claude writes the files, compiles, done in ~20 minutes
- Actual behavior:
- Claude invoked
brainstormingskill (unnecessary for a clear spec) - Claude invoked
writing-plansskill (created 1000+ line plan for a tiny project) - Claude invoked
subagent-driven-developmentskill which: - Launched a separate "implementer" subagent for each of 11 tasks
- Launched a "spec compliance reviewer" subagent after each task
- Launched a "code quality reviewer" subagent after each task
- Created review loops that repeated multiple times
- Result: 33+ subagent invocations for what could be done directly
- Additional issues:
- Rust wasn't installed on the system - Claude should have checked this first
- Claude spent tokens on redundant reviews instead of just writing code
- When interrupted, Claude kept trying to follow the skill workflows
Token/Cost Impact
- Estimated 10-50x more tokens consumed than necessary
- Hours instead of minutes
- User had to interrupt multiple times to stop the loops
Root Cause
The subagent-driven-development skill enforces a rigid workflow:
For each task:
1. Dispatch implementer subagent
2. Dispatch spec reviewer subagent
3. If issues → implementer fixes → spec reviewer again
4. Dispatch code quality reviewer subagent
5. If issues → implementer fixes → code reviewer againThis might make sense for large enterprise projects but is wildly excessive for small projects. Claude followed the skill instructions literally without applying judgment about proportionality.
Suggested Fixes
- Add complexity threshold: Skills should only activate for projects above a certain size/complexity
- Allow Claude to override: Claude should be able to say "this project is too simple for this workflow"
- Warn about token consumption: Alert users when a skill will launch multiple subagents
- Better defaults: Don't enable expensive multi-agent workflows by default
Reproduction Steps
- Install
superpowersplugin - Ask Claude to create a small CLI project
- Observe excessive subagent spawning and review cycles
User Impact
- Wasted entire day
- Significant unexpected cost in tokens
- Frustrating experience that damaged trust in Claude Code
What Should Happen?
9 hs working for 300 lines of code super simple script to sin-tax highlight a mark-down file on a terminal
Error Messages/Logs
implementation plan completely over killed
# mdcli Implementation Plan
> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
**Goal:** Build a Rust CLI that renders Markdown files with rich terminal formatting, supporting both stream and pager modes.
**Architecture:** CLI parses args with clap, reads file/stdin, parses Markdown with pulldown-cmark, renders to styled terminal output with crossterm, and optionally displays in pager mode with minus. Theme adapts to light/dark terminal.
**Tech Stack:** Rust, clap, pulldown-cmark, crossterm, syntect, minus, terminal-light, anyhow
---
## Task 1: Project Scaffolding
**Files:**
- Create: `Cargo.toml`
- Create: `src/main.rs`
- Create: `src/lib.rs`
**Step 1: Initialize Cargo project**
Run:
cargo init
**Step 2: Replace Cargo.toml with dependencies**
[package]
name = "mdcli"
version = "0.1.0"
edition = "2021"
description = "Render Markdown files beautifully in the terminal"
[dependencies]
clap = { version = "4", features = ["derive"] }
pulldown-cmark = "0.10"
crossterm = "0.27"
syntect = { version = "5", default-features = false, features = ["default-fancy"] }
minus = { version = "5", features = ["search", "static_output"] }
terminal-light = "1"
anyhow = "1"
**Step 3: Create minimal main.rs**
use anyhow::Result;
fn main() -> Result<()> {
println!("mdcli");
Ok(())
}
**Step 4: Create lib.rs with module declarations**
pub mod parser;
pub mod renderer;
pub mod theme;
pub mod pager;
pub mod highlight;
**Step 5: Create placeholder modules**
Create `src/parser.rs`:
//! Markdown parsing with pulldown-cmark
Create `src/renderer.rs`:
//! Convert parsed Markdown to styled terminal output
Create `src/theme.rs`:
//! Color definitions and light/dark detection
Create `src/pager.rs`:
//! Pager mode implementation
Create `src/highlight.rs`:
//! Syntax highlighting with syntect
**Step 6: Verify it compiles**
Run: `cargo build`
Expected: Compiles successfully
**Step 7: Commit**
git add Cargo.toml src/
git commit -m "feat: initialize Rust project with dependencies"
---
## Task 2: CLI Argument Parsing
**Files:**
- Modify: `src/main.rs`
- Create: `tests/cli_tests.rs`
**Step 1: Write test for CLI parsing**
Create `tests/cli_tests.rs`:
use std::process::Command;
#[test]
fn test_help_flag() {
let output = Command::new("cargo")
.args(["run", "--", "--help"])
.output()
.expect("Failed to execute");
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(stdout.contains("mdcli"));
assert!(stdout.contains("--pager"));
}
#[test]
fn test_missing_file_error() {
let output = Command::new("cargo")
.args(["run", "--", "nonexistent.md"])
.output()
.expect("Failed to execute");
assert!(!output.status.success());
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(stderr.contains("not found") || stderr.contains("No such file"));
}
**Step 2: Run test to verify it fails**
Run: `cargo test --test cli_tests`
Expected: FAIL (no --pager flag yet)
**Step 3: Implement CLI with clap**
Replace `src/main.rs`:
use anyhow::{Context, Result};
use clap::Parser;
use std::fs;
use std::io::{self, Read};
use std::path::PathBuf;
#[derive(Parser)]
#[command(name = "mdcli")]
#[command(about = "Render Markdown files beautifully in the terminal")]
struct Cli {
/// Markdown file to display (reads from stdin if not provided)
file: Option<PathBuf>,
/// Use pager mode for scrolling
#[arg(short, long)]
pager: bool,
}
fn main() -> Result<()> {
let cli = Cli::parse();
let content = match cli.file {
Some(path) => {
fs::read_to_string(&path)
.with_context(|| format!("File not found: {}", path.display()))?
}
None => {
let mut buffer = String::new();
io::stdin()
.read_to_string(&mut buffer)
.context("Failed to read from stdin")?;
buffer
}
};
// TODO: Parse and render
println!("{}", content);
Ok(())
}
**Step 4: Run tests to verify they pass**
Run: `cargo test --test cli_tests`
Expected: PASS
**Step 5: Commit**
git add src/main.rs tests/
git commit -m "feat: add CLI argument parsing with clap"
---
## Task 3: Theme Detection
**Files:**
- Modify: `src/theme.rs`
- Create: `src/theme/colors.rs` (inline in theme.rs for simplicity)
**Step 1: Implement theme module**
Replace `src/theme.rs`:
//! Color definitions and light/dark detection
use crossterm::style::Color;
use terminal_light::luma;
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum TerminalTheme {
Light,
Dark,
}
impl TerminalTheme {
pub fn detect() -> Self {
match luma() {
Ok(luma) if luma > 0.5 => TerminalTheme::Light,
_ => TerminalTheme::Dark, // Default to dark
}
}
}
#[derive(Debug, Clone)]
pub struct Theme {
pub h1: Color,
pub h2: Color,
pub h3: Color,
pub bold: Color,
pub italic: Color,
pub code_fg: Color,
pub code_bg: Color,
pub link: Color,
pub link_url: Color,
pub blockquote: Color,
pub blockquote_bar: Color,
pub hr: Color,
pub list_bullet: Color,
}
impl Theme {
pub fn for_terminal(terminal: TerminalTheme) -> Self {
match terminal {
TerminalTheme::Dark => Self::dark(),
TerminalTheme::Light => Self::light(),
}
}
fn dark() -> Self {
Self {
h1: Color::Cyan,
h2: Color::Cyan,
h3: Color::DarkCyan,
bold: Color::White,
italic: Color::White,
code_fg: Color::Yellow,
code_bg: Color::DarkGrey,
link: Color::Blue,
link_url: Color::DarkGrey,
blockquote: Color::DarkGrey,
blockquote_bar: Color::DarkCyan,
hr: Color::DarkGrey,
list_bullet: Color::Cyan,
}
}
fn light() -> Self {
Self {
h1: Color::DarkBlue,
h2: Color::DarkBlue,
h3: Color::DarkCyan,
bold: Color::Black,
italic: Color::Black,
code_fg: Color::DarkRed,
code_bg: Color::Rgb { r: 240, g: 240, b: 240 },
link: Color::Blue,
link_url: Color::DarkGrey,
blockquote: Color::DarkGrey,
blockquote_bar: Color::DarkBlue,
hr: Color::Grey,
list_bullet: Color::DarkBlue,
}
}
}
**Step 2: Verify it compiles**
Run: `cargo build`
Expected: Compiles successfully
**Step 3: Commit**
git add src/theme.rs
git commit -m "feat: add theme detection and color definitions"
---
## Task 4: Markdown Parser
**Files:**
- Modify: `src/parser.rs`
**Step 1: Implement parser wrapper**
Replace `src/parser.rs`:
//! Markdown parsing with pulldown-cmark
use pulldown_cmark::{Event, Options, Parser, Tag, TagEnd, CodeBlockKind};
pub struct MarkdownParser<'a> {
parser: Parser<'a, 'a>,
}
impl<'a> MarkdownParser<'a> {
pub fn new(content: &'a str) -> Self {
let options = Options::ENABLE_TABLES
| Options::ENABLE_STRIKETHROUGH
| Options::ENABLE_TASKLISTS;
Self {
parser: Parser::new_ext(content, options),
}
}
}
impl<'a> Iterator for MarkdownParser<'a> {
type Item = Event<'a>;
fn next(&mut self) -> Option<Self::Item> {
self.parser.next()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_heading() {
let content = "# Hello";
let parser = MarkdownParser::new(content);
let events: Vec<_> = parser.collect();
assert!(events.iter().any(|e| matches!(e, Event::Start(Tag::Heading { level, .. }) if *level == pulldown_cmark::HeadingLevel::H1)));
}
#[test]
fn test_parse_code_block() {
let content = "\nfn main() {}\n";
let parser = MarkdownParser::new(content);
let events: Vec<_> = parser.collect();
assert!(events.iter().any(|e| matches!(e, Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(lang))) if lang.as_ref() == "rust")));
}
}
**Step 2: Run tests**
Run: `cargo test parser`
Expected: PASS
**Step 3: Commit**
git add src/parser.rs
git commit -m "feat: add Markdown parser wrapper"
---
## Task 5: Syntax Highlighting
**Files:**
- Modify: `src/highlight.rs`
**Step 1: Implement syntax highlighter**
Replace `src/highlight.rs`:
//! Syntax highlighting with syntect
use syntect::easy::HighlightLines;
use syntect::highlighting::{Style, ThemeSet};
use syntect::parsing::SyntaxSet;
use syntect::util::as_24_bit_terminal_escaped;
pub struct Highlighter {
syntax_set: SyntaxSet,
theme_set: ThemeSet,
is_light: bool,
}
impl Highlighter {
pub fn new(is_light: bool) -> Self {
Self {
syntax_set: SyntaxSet::load_defaults_newlines(),
theme_set: ThemeSet::load_defaults(),
is_light,
}
}
pub fn highlight(&self, code: &str, language: &str) -> String {
let theme_name = if self.is_light {
"InspiredGitHub"
} else {
"base16-ocean.dark"
};
let theme = &self.theme_set.themes[theme_name];
let syntax = self
.syntax_set
.find_syntax_by_token(language)
.unwrap_or_else(|| self.syntax_set.find_syntax_plain_text());
let mut highlighter = HighlightLines::new(syntax, theme);
let mut output = String::new();
for line in code.lines() {
match highlighter.highlight_line(line, &self.syntax_set) {
Ok(ranges) => {
output.push_str(&as_24_bit_terminal_escaped(&ranges[..], false));
output.push('\n');
}
Err(_) => {
output.push_str(line);
output.push('\n');
}
}
}
// Reset terminal colors
output.push_str("\x1b[0m");
output
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_highlight_rust() {
let highlighter = Highlighter::new(false);
let code = "fn main() {}";
let result = highlighter.highlight(code, "rust");
// Should contain escape codes
assert!(result.contains("\x1b["));
}
#[test]
fn test_unknown_language_fallback() {
let highlighter = Highlighter::new(false);
let code = "some code";
let result = highlighter.highlight(code, "unknownlang123");
// Should still produce output
assert!(result.contains("some code"));
}
}
**Step 2: Run tests**
Run: `cargo test highlight`
Expected: PASS
**Step 3: Commit**
git add src/highlight.rs
git commit -m "feat: add syntax highlighting with syntect"
---
## Task 6: Renderer - Basic Structure
**Files:**
- Modify: `src/renderer.rs`
**Step 1: Implement basic renderer**
Replace `src/renderer.rs`:
//! Convert parsed Markdown to styled terminal output
use crossterm::style::{Attribute, Color, SetAttribute, SetForegroundColor, SetBackgroundColor, ResetColor};
use pulldown_cmark::{Event, Tag, TagEnd, CodeBlockKind, HeadingLevel};
use std::fmt::Write;
use crate::highlight::Highlighter;
use crate::theme::Theme;
pub struct Renderer {
theme: Theme,
highlighter: Highlighter,
output: String,
// State tracking
in_code_block: bool,
code_block_lang: String,
code_block_content: String,
list_depth: usize,
ordered_list_index: Option<u64>,
in_heading: Option<HeadingLevel>,
pending_link_url: Option<String>,
}
impl Renderer {
pub fn new(theme: Theme, is_light: bool) -> Self {
Self {
theme,
highlighter: Highlighter::new(is_light),
output: String::new(),
in_code_block: false,
code_block_lang: String::new(),
code_block_content: String::new(),
list_depth: 0,
ordered_list_index: None,
in_heading: None,
pending_link_url: None,
}
}
pub fn render<'a>(&mut self, events: impl Iterator<Item = Event<'a>>) -> &str {
for event in events {
self.process_event(event);
}
&self.output
}
fn process_event(&mut self, event: Event) {
match event {
Event::Start(tag) => self.start_tag(tag),
Event::End(tag) => self.end_tag(tag),
Event::Text(text) => self.text(&text),
Event::Code(code) => self.inline_code(&code),
Event::SoftBreak => self.output.push(' '),
Event::HardBreak => self.output.push('\n'),
Event::Rule => self.horizontal_rule(),
_ => {}
}
}
fn start_tag(&mut self, tag: Tag) {
match tag {
Tag::Heading { level, .. } => {
self.in_heading = Some(level);
let color = match level {
HeadingLevel::H1 => self.theme.h1,
HeadingLevel::H2 => self.theme.h2,
_ => self.theme.h3,
};
write!(self.output, "{}{}", SetForegroundColor(color), SetAttribute(Attribute::Bold)).unwrap();
if level == HeadingLevel::H1 {
write!(self.output, "{}", SetAttribute(Attribute::Underlined)).unwrap();
}
}
Tag::Paragraph => {
if !self.output.is_empty() && !self.output.ends_with('\n') {
self.output.push('\n');
}
}
Tag::Strong => {
write!(self.output, "{}", SetAttribute(Attribute::Bold)).unwrap();
}
Tag::Emphasis => {
write!(self.output, "{}", SetAttribute(Attribute::Italic)).unwrap();
}
Tag::CodeBlock(kind) => {
self.in_code_block = true;
self.code_block_content.clear();
self.code_block_lang = match kind {
CodeBlockKind::Fenced(lang) => lang.to_string(),
CodeBlockKind::Indented => String::new(),
};
}
Tag::BlockQuote(_) => {
write!(self.output, "{}│ {}",
SetForegroundColor(self.theme.blockquote_bar),
SetForegroundColor(self.theme.blockquote)
).unwrap();
}
Tag::List(start) => {
self.list_depth += 1;
self.ordered_list_index = start;
}
Tag::Item => {
let indent = " ".repeat(self.list_depth.saturating_sub(1));
if let Some(idx) = &mut self.ordered_list_index {
write!(self.output, "{}{}. ", indent, idx).unwrap();
*idx += 1;
} else {
write!(self.output, "{}{}• {}",
indent,
SetForegroundColor(self.theme.list_bullet),
ResetColor
).unwrap();
}
}
Tag::Link { dest_url, .. } => {
self.pending_link_url = Some(dest_url.to_string());
write!(self.output, "{}{}",
SetForegroundColor(self.theme.link),
SetAttribute(Attribute::Underlined)
).unwrap();
}
Tag::Table(_) => {
self.output.push('\n');
}
Tag::TableHead => {}
Tag::TableRow => {}
Tag::TableCell => {
self.output.push_str("│ ");
}
_ => {}
}
}
fn end_tag(&mut self, tag: TagEnd) {
match tag {
TagEnd::Heading(_) => {
self.in_heading = None;
write!(self.output, "{}\n\n", ResetColor).unwrap();
}
TagEnd::Paragraph => {
write!(self.output, "{}\n", ResetColor).unwrap();
}
TagEnd::Strong | TagEnd::Emphasis => {
write!(self.output, "{}", SetAttribute(Attribute::Reset)).unwrap();
}
TagEnd::CodeBlock => {
self.in_code_block = false;
let highlighted = self.highlighter.highlight(&self.code_block_content, &self.code_block_lang);
self.output.push_str("\n");
self.output.push_str(&highlighted);
self.output.push_str("\n");
}
TagEnd::BlockQuote(_) => {
write!(self.output, "{}\n", ResetColor).unwrap();
}
TagEnd::List(_) => {
self.list_depth = self.list_depth.saturating_sub(1);
if self.list_depth == 0 {
self.ordered_list_index = None;
}
}
TagEnd::Item => {
self.output.push('\n');
}
TagEnd::Link => {
write!(self.output, "{}", SetAttribute(Attribute::NoUnderline)).unwrap();
if let Some(url) = self.pending_link_url.take() {
write!(self.output, " {}({}){}",
SetForegroundColor(self.theme.link_url),
url,
ResetColor
).unwrap();
}
}
TagEnd::TableHead => {
self.output.push_str("│\n");
self.output.push_str("├───────────────────┤\n");
}
TagEnd::TableRow => {
self.output.push_str("│\n");
}
TagEnd::TableCell => {}
TagEnd::Table => {
self.output.push('\n');
}
_ => {}
}
}
fn text(&mut self, text: &str) {
if self.in_code_block {
self.code_block_content.push_str(text);
} else {
self.output.push_str(text);
}
}
fn inline_code(&mut self, code: &str) {
write!(self.output, "{}{} {} {}{}",
SetBackgroundColor(self.theme.code_bg),
SetForegroundColor(self.theme.code_fg),
code,
ResetColor,
SetBackgroundColor(Color::Reset)
).unwrap();
}
fn horizontal_rule(&mut self) {
write!(self.output, "\n{}─────────────────────────────────────{}\n\n",
SetForegroundColor(self.theme.hr),
ResetColor
).unwrap();
}
}
**Step 2: Verify it compiles**
Run: `cargo build`
Expected: Compiles successfully
**Step 3: Commit**
git add src/renderer.rs
git commit -m "feat: add Markdown renderer with styling"
---
## Task 7: Pager Mode
**Files:**
- Modify: `src/pager.rs`
**Step 1: Implement pager**
Replace `src/pager.rs`:
//! Pager mode implementation with minus
use anyhow::Result;
use minus::{ExitStrategy, Pager};
use std::fmt::Write;
pub fn display_in_pager(content: &str) -> Result<()> {
let mut pager = Pager::new();
pager.set_exit_strategy(ExitStrategy::PagerQuit)?;
pager.set_prompt("mdcli (q to quit, / to search)")?;
write!(pager, "{}", content)?;
minus::page_all(pager)?;
Ok(())
}
**Step 2: Verify it compiles**
Run: `cargo build`
Expected: Compiles successfully
**Step 3: Commit**
git add src/pager.rs
git commit -m "feat: add pager mode with minus"
---
## Task 8: Wire Everything Together
**Files:**
- Modify: `src/main.rs`
**Step 1: Update main.rs to use all modules**
Replace `src/main.rs`:
use anyhow::{Context, Result};
use clap::Parser;
use std::fs;
use std::io::{self, Read, Write};
use std::path::PathBuf;
mod highlight;
mod pager;
mod parser;
mod renderer;
mod theme;
use parser::MarkdownParser;
use renderer::Renderer;
use theme::{TerminalTheme, Theme};
#[derive(Parser)]
#[command(name = "mdcli")]
#[command(about = "Render Markdown files beautifully in the terminal")]
struct Cli {
/// Markdown file to display (reads from stdin if not provided)
file: Option<PathBuf>,
/// Use pager mode for scrolling
#[arg(short, long)]
pager: bool,
}
fn main() -> Result<()> {
let cli = Cli::parse();
let content = match cli.file {
Some(path) => {
fs::read_to_string(&path)
.with_context(|| format!("File not found: {}", path.display()))?
}
None => {
let mut buffer = String::new();
io::stdin()
.read_to_string(&mut buffer)
.context("Failed to read from stdin")?;
buffer
}
};
let terminal_theme = TerminalTheme::detect();
let is_light = terminal_theme == TerminalTheme::Light;
let theme = Theme::for_terminal(terminal_theme);
let parser = MarkdownParser::new(&content);
let mut renderer = Renderer::new(theme, is_light);
let rendered = renderer.render(parser);
if cli.pager {
pager::display_in_pager(rendered)?;
} else {
let mut stdout = io::stdout().lock();
stdout.write_all(rendered.as_bytes())?;
stdout.flush()?;
}
Ok(())
}
**Step 2: Update lib.rs**
Replace `src/lib.rs`:
pub mod highlight;
pub mod pager;
pub mod parser;
pub mod renderer;
pub mod theme;
pub use parser::MarkdownParser;
pub use renderer::Renderer;
pub use theme::{TerminalTheme, Theme};
**Step 3: Build and test manually**
Run: `cargo build --release`
Expected: Compiles successfully
Run: `cargo run -- README.md` (or any .md file)
Expected: Renders with colors
**Step 4: Commit**
git add src/main.rs src/lib.rs
git commit -m "feat: wire up all components in main"
---
## Task 9: Integration Tests
**Files:**
- Modify: `tests/cli_tests.rs`
**Step 1: Add more integration tests**
Add to `tests/cli_tests.rs`:
#[test]
fn test_stdin_input() {
use std::process::{Command, Stdio};
use std::io::Write;
let mut child = Command::new("cargo")
.args(["run", "--"])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.spawn()
.expect("Failed to spawn");
let stdin = child.stdin.as_mut().expect("Failed to open stdin");
stdin.write_all(b"# Hello World").expect("Failed to write");
drop(child.stdin.take());
let output = child.wait_with_output().expect("Failed to wait");
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(stdout.contains("Hello World"));
}
#[test]
fn test_pager_flag_accepted() {
let output = Command::new("cargo")
.args(["run", "--", "--help"])
.output()
.expect("Failed to execute");
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(stdout.contains("-p, --pager"));
}
**Step 2: Run all tests**
Run: `cargo test`
Expected: All tests PASS
**Step 3: Commit**
git add tests/cli_tests.rs
git commit -m "test: add integration tests for stdin and pager flag"
---
## Task 10: Create README
**Files:**
- Create: `README.md`
**Step 1: Write README**
# mdcli
Render Markdown files beautifully in the terminal.
## Installation
cargo install --path .
## Usage
# Display a markdown file
mdcli README.md
# Use pager mode for scrolling
mdcli --pager README.md
mdcli -p README.md
# Read from stdin
cat README.md | mdcli
echo "# Hello" | mdcli --pager
## Features
- Headers with colors and styling
- Bold and italic text
- Syntax-highlighted code blocks
- Lists (ordered and unordered)
- Links with visible URLs
- Blockquotes
- Tables
- Horizontal rules
- Auto-detects light/dark terminal theme
## Pager Controls
| Key | Action |
|-----|--------|
| `j` / `↓` | Scroll down |
| `k` / `↑` | Scroll up |
| `d` | Half page down |
| `u` | Half page up |
| `g` | Go to top |
| `G` | Go to bottom |
| `q` | Quit |
| `/` | Search |
## License
MIT
**Step 2: Test that README renders**
Run: `cargo run -- README.md`
Expected: README displays with formatting
**Step 3: Commit**
git add README.md
git commit -m "docs: add README with usage instructions"
---
## Task 11: Final Polish
**Step 1: Run clippy**
Run: `cargo clippy -- -D warnings`
Fix any warnings
**Step 2: Format code**
Run: `cargo fmt`
**Step 3: Final test run**
Run: `cargo test`
Expected: All PASS
**Step 4: Build release**
Run: `cargo build --release`
**Step 5: Final commit**
git add -A
git commit -m "chore: clippy fixes and formatting"
**Step 6: Tag release**
git tag v0.1.0
---
## Summary
After completing all tasks you will have:
- A working `mdcli` binary in `target/release/`
- Stream mode (default) and pager mode (`--pager`)
- Syntax highlighting for code blocks
- Auto-detection of light/dark terminal
- Full test coverage
- Clean, documented codeSteps to Reproduce
la aplicación muestra un archivo con formato Mark Down en una terminal de texto utilizando colores y negritas en lugar de los caracteres de control de markdown. Me imagino sin ser una limitación que podría recibir el nombre de un archivo .md y mostrarlo con un scroll Down pero formateado en modo terminal
Claude Model
Opus
Is this a regression?
Yes, this worked in a previous version
Last Working Version
_No response_
Claude Code Version
2.1.22 (Claude Code)
Platform
Anthropic API
Operating System
macOS
Terminal/Shell
Terminal.app (macOS)
Additional Information
_No response_
This issue has 3 comments on GitHub. Read the full discussion on GitHub ↗