DEV Community: k1lgor

🐳 I Built a Container Dashboard for Your AI Coding Agent — And It's Awesome

k1lgor — Mon, 04 May 2026 11:45:15 +0000

The Problem

If you're like me, you live in your terminal. You've got Docker containers running for databases, Redis instances for caching, microservices doing their thing — and you're constantly context-switching to check on them.

# The old way:
docker ps
docker logs my-app -n 50
docker stats
docker inspect some_container
# ... back and forth, breaking your flow

Now imagine you're working with an AI coding agent — an LLM that can read files, write code, and run commands for you. Every time you need to check a container, you either:

Break your flow by typing out commands manually
Trust the AI to blindly run docker rm -f without confirmation (yikes!)
Squint at raw JSON output from docker inspect

I wanted something better. So I built it.

🐳 Enter: Container Dashboard

Container Dashboard is a pi coding agent extension that brings full container lifecycle management into your AI agent. It's like having Docker Desktop — but inside your LLM-powered terminal, with safety guarantees baked in.

It works with Docker, Podman, and Nerdctl — all three major container runtimes.

✨ The Coolest Features

📊 Live TUI Widget

Your AI coding agent's sidebar shows a live container count at all times. You always know what's running without asking:

🐳 Docker v24.0.7  |  ▶ 3 running  |  ● 8 total

🎯 14 Slash Commands

Type /docker:ps and instantly get a formatted table. /docker:stats shows CPU & memory. /docker:logs my-app -n 100 tails logs. Here's the full arsenal:

Command	Superpower
`/docker:ps`	List containers (with `--running` or `--all` flags)
`/docker:logs <name>`	Tail logs with `-n` line control
`/docker:stats`	Live CPU, memory, and network I/O
`/docker:inspect <name>`	Deep-dive into container config (JSON parsed beautifully)
`/docker:top <name>`	See processes running inside a container
`/docker:images`	Browse all pulled images with sizes
`/docker:prune`	Remove stopped containers (+ `--images` or `--all`)
`/docker:stop/start/restart <name>`	Lifecycle control
`/docker:rm <name>`	Remove containers or images
`/docker:detect`	Re-detect the container runtime

🤖 13 LLM Tools

Your AI agent can proactively manage containers using tools like container_ps, container_stats, container_logs, and container_prune_system. It can check what's running, diagnose issues, and clean up — all autonomously but safely.

🛡️ Safety First — Built-in Confirmations

This is my favorite part. Dangerous commands get intercepted:

const dangerousPatterns = [
  /(?:docker|podman|nerdctl)\s+(?:rm|container\s+rm)\s+-f/i,
  /(?:docker|podman|nerdctl)\s+system\s+prune\s+-a/i,
  /(?:docker|podman|nerdctl)\s+stop\s+\$\(docker\s+ps\s+-aq\)/i,
  // ...
];

Before the AI can:

Force-remove a running container
System prune everything
Stop ALL containers at once

...it hits a confirmation dialog. The AI literally asks "Are you sure?" before pulling the trigger. 🎯

No more accidental docker system prune -a wiping your CI cache while the AI was "just trying to help."

🧱 How It Works Under the Hood

The architecture is surprisingly clean — 5 TypeScript files, ~800 lines total:

container-dashboard/
├── index.ts       # Entry point, permission gates, lifecycle hooks
├── runtime.ts     # Runtime detection (docker → podman → nerdctl), CLI abstraction
├── commands.ts    # /docker:* slash commands with formatted output
├── tools.ts       # 13 LLM tools registered via TypeBox schemas
└── widget.ts      # Live TUI sidebar widget

Runtime Detection: Auto-Discovery

The extension auto-detects which container runtime you have installed by checking docker, then podman, then nerdctl in priority order. It also grabs the version string so you see Docker v24.0.7 instead of just "Docker."

const RUNTIMES = ["docker", "podman", "nerdctl"] as const;

export async function detectRuntime(pi: ExtensionAPI): Promise<RuntimeState> {
  for (const runtime of RUNTIMES) {
    try {
      const result = await pi.exec(runtime, ["--version"], { timeout: 3000 });
      if (result.code === 0 && result.stdout) {
        return { runtime, version: result.stdout.trim(), available: true };
      }
    } catch {
      continue;
    }
  }
  return { runtime: null, version: "", available: false };
}

Cross-Runtime Compatibility

Every function — listContainers, getContainerLogs, pruneSystem, getContainerStats — works identically across Docker, Podman, and Nerdctl because they all share the same CLI interface for basic operations. The extension parses JSON output from docker ps --format '{{json .}}', normalizes status fields, and handles the slight differences between Docker's and Podman's JSON schemas.

Beautiful Terminal Tables

No more raw JSON. The commands render colorized, formatted tables with proper padding, truncation, and status colors:

 Containers

CONTAINER ID   NAME                IMAGE                    STATUS      PORTS
a1b2c3d4e5f6   my-postgres         postgres:16              ▶ running   5432→5432
b2c3d4e5f6a7   redis-cache         redis:7-alpine           ▶ running   6379→6379
c3d4e5f6a7b8   old-test-container  node:18                  ● exited    —

Smart Inspect Parsing

/docker:inspect takes the raw JSON dump and extracts the useful bits — ports, environment variables, mounted volumes, IP address, command — and displays them as a clean summary instead of a JSON firehose.

📦 Installation (60 seconds)

# From npm (recommended)
pi install npm:container-dashboard

# Or from GitHub
pi install git:github.com/k1lgor/pi-container-dashboard

# Or load locally
pi -e ./path/to/index.ts

That's it. The extension auto-detects your container runtime at startup and starts tracking containers immediately.

🚀 Real-World Workflow

Here's what a typical session looks like:

You: "What containers are running?"

🤖 AI: *calls container_ps*
▶ my-postgres (running)
▶ redis-cache (running)
▶ api-gateway (running)

You: "Check the api-gateway logs, something's wrong"

🤖 AI: *calls container_logs("api-gateway", 100)*
📋 Logs for api-gateway:
Error: Connection refused to postgres:5432
    at ...

You: "Restart it"

🤖 AI: *calls container_restart("api-gateway")*
🔄 Restarted api-gateway

You: "Clean up old containers, but save the images"

🤖 AI: *calls container_prune*
🗑️ Pruned 3 stopped containers. Freed: 1.2GB

No context switching. No leaving your AI agent. No accidentally running dangerous commands.

💡 Why I Built This

I've been using AI coding agents for months, and the biggest friction point was always permission boundaries. I wanted my AI to be useful — to actually manage infrastructure, not just generate code. But giving an LLM raw access to docker commands is terrifying.

This extension solves that tension:

The AI gets agency — it can check logs, restart services, clean up disk space
You get safety — every destructive action requires confirmation
Everyone gets pretty output — formatted tables instead of JSON vomit

It's a pattern I think we'll see more of: AI agents with guardrails, not blacklists. Give them a sandbox, define safe patterns, and let them do real work.

🛠️ Tech Stack

TypeScript 5 — Fully typed, strict mode
pi coding agent SDK — Extension API hooks
TypeBox — Runtime type validation for LLM tool parameters
Zero external dependencies for the runtime logic — pure pi.exec() calls

📊 Stats & Facts

Metric	Value
Lines of code	~800
Source files	5
Slash commands	14
LLM tools	13
Supported runtimes	3 (Docker, Podman, Nerdctl)
GitHub	k1lgor/pi-container-dashboard

🔗 Get Started

GitHub: https://github.com/k1lgor/pi-container-dashboard
npm: pi install npm:container-dashboard
License: MIT — go build something cool with it

💬 What Do You Think?

I'm excited about this pattern of guardrailed AI infrastructure management. Have you tried giving your AI coding agent access to Docker or other infrastructure tools? How do you handle the safety vs. agency tradeoff?

Drop a comment below — I'd love to hear your thoughts!

Built with ❤️ and 🤖 by @k1lgor

I Taught My AI Assistant to Remember (And Saved 99% of Its Brain)

k1lgor — Thu, 30 Apr 2026 17:29:43 +0000

The Problem: Your AI Is a Goldfish

Here's a scene that plays out in my terminal every single day:

Me: "Hey AI, what's the architecture of this project?"

AI: runs ls, runs find, runs grep, reads 15 files, spends 28,000 tokens

AI: "Here's the architecture! It's Express with MongoDB!"

Me: "Great, now implement the login route."

AI: runs ls, runs find, reads the same 15 files again, spends another 25,000 tokens

Me: quietly sobbing over my API bill

If you've used any AI coding assistant (Cursor, Copilot, Claude Code, Devin, whatever), you've seen this. The LLM has the memory of a goldfish. Every new turn is like waking up in a strange room going "Who am I? Where am I? What project is this? Let me read everything again."

It's not the LLM's fault. These models have context windows, not persistent memory. They can't close their eyes and remember that your project uses Express with MongoDB — they have to re-discover reality from scratch every time.

But here's the thing nobody talks about: This costs you a fortune.

The Price of Being a Goldfish

Let's put real numbers on it.

In a typical coding session, an LLM agent will explore the project by running ls, find, grep, and reading files. A lot of files. Every. Single. Turn.

I benchmarked this against real repos on GitHub. Here's what I found:

Repository	Files	Token Cost to Explore (read everything)	Token Cost with Memoir
A small side project (53 files)	246,000 tokens	~10K tokens	96%
A medium React app (258 files)	826,000 tokens	~41K tokens	95%
A serious codebase (2,538 files)	12.2 MILLION tokens	~67K tokens	99%
TypeScript compiler (40,877 files)	36 MILLION tokens	~19K tokens	~100%

Let me repeat that last one:

36 million tokens to explore the TypeScript repo with traditional methods. 19 thousand with the memoir.

That's a ~99.95% reduction.

Or, put another way: every time your AI asks "what's in this project?", it's burning through the equivalent of 72 copies of the Great Gatsby in tokens. When it could be burning through a single tweet.

The Insight: Project Knowledge Almost Never Changes

The core realization is so obvious it hurts:

Your project's basic structure, dependencies, entry points, and source files change maybe once a day. Your LLM queries it 20 times per session.

Why are we paying 30,000 tokens to rediscover the same package.json every 45 seconds?!

If a human dev joined your team, you wouldn't make them re-read the entire codebase every time they wanted to write a function. You'd say "the routes are in src/api/, the DB layer is in src/db/, here's the README." They'd remember.

Why can't our AI assistants do the same?

Well… now they can.

Enter pi-memoir

pi-memoir (pronounced pi-mem-wahr, like the French word for memory — because developers love obscure multilingual puns) is an extension for the pi coding agent that gives your LLM persistent project memory.

Here's what it does in one sentence:

Harvest your project's structure once. Let the LLM query it for ~100 tokens instead of ~30,000. Forever.

How it works

Your Project/
└── .pi/memoir/
    └── memories.jsonl    ← Everything the AI knows, in one file

When you run /memo harvest (or call memo_harvest), pi-memoir walks every file in your project and builds a compact knowledge base:

📄 README → tagged project:readme
📦 package.json → tagged project:manifest
🏗️ Directory tree → tagged project:structure
🚪 Entry points → tagged project:entry
⚙️ Config files → tagged project:config
Every single source file → tagged project:file + file:path/to/file.ts

That's right — it stores a memory for every .ts, .js, .py, .rs, .go, .rb, .vue, .svelte — actually 128 file extensions in total. Up to 200 files, each under 20KB. Smart summaries per file type. It skips node_modules, .git, dist, and all the usual junk.

Then the magic happens.

The "DON'T USE BASH" Rule

The extension injects a single instruction at the top of every system prompt:

=== PI-MEMOIRE: DON'T USE BASH — USE THE MEMOIRE ===
CRITICAL: Before running ANY bash/ls/find/grep/wc/read commands
to explore the project, you MUST call memo_search first.
Querying the memoir costs ~100 tokens. Running bash to discover
the same info costs ~2,000+ tokens.

• "what's the architecture?" → memo_search({ query: "architecture" })
• "what files?" → memo_search({ tags: "project:structure" })
• "dependencies?" → memo_search({ query: "package" })
...
If memo_search returns nothing, THEN fall back to bash/read.

Think of it as telling your AI: "Check your notes before you run around the office asking questions."

And because the tools (memo_search, memo_store, memo_harvest) are registered as first-class LLM callable tools — same as read, bash, or edit — the model actually uses them. It's not a suggestion. It's a protocol.

The Numbers That Made My Jaw Drop

I ran pi-memoir against six real-world repositories — from a 53-file side project to the 40,877-file TypeScript compiler — and measured the token cost of two approaches:

The Old Way: LLM runs bash/ls/find/grep, reads files one by one
The Memoir Way: LLM calls memo_search with keywords

Repository	Files	Size	Old Way	Memoir Way	Savings
VibeVoice	53	264 MB	~246K tok	~10K tok	96%
rtk	258	4.5 MB	~826K tok	~41K tok	95%
claude-mem	679	104 MB	~2.7M tok	~55K tok	98%
oh-my-codex	921	15 MB	~2.9M tok	~71K tok	98%
hermes-agent	2,538	64 MB	~12.2M tok	~67K tok	99%
TypeScript	40,877	548 MB	~36M tok	~19K tok	~100%

The chart is basically comedy:

Token Cost:  The Old Way ████████████████████████████████████████ 36,000,000
            The Memoir Way ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▏     19,000

Every repo, every language, every size — 95-100% savings. Not "theoretically." Not "in ideal conditions." Real repos, real numbers.

What This Means for Your Wallet

Running Claude Sonnet 3.5 at $3/M input tokens:

Without memoir: 1 session × 10 explorations × 30K tokens = 300K tokens = $0.90/session
With memoir: 1 session × 1 harvest (30K) + 9 searches (100 each) = 30.9K tokens = $0.09/session

On a team of 10 devs doing 5 sessions a day? That's $4,500/month → $450/month.

Your AI just got 10x cheaper. And you don't have to buy it a fishbowl.

The Quirky Bits

It stores memories in a JSONL file

Yes, the entire "knowledge base" is a flat JSONL file in .pi/memoir/memories.jsonl. No vector database. No Postgres. No Redis. A flat file.

And you know what? It works better. The memoir stores 500-odd memories for a 40K-file project in ~200KB of text. That's smaller than a single JPEG of a cat. And JSONL means you can grep it, wc -l it, pipe it through jq, check it into git, read it on your phone while commuting. It's the most portable "database" in the universe.

Zero external dependencies

Seven TypeScript files. 1,597 lines of code. Zero npm dependencies.

It uses typebox — which is bundled with pi anyway — and that's it. No vector DBs, no embeddings APIs, no LLM calls at harvest time. Just the filesystem, JSON.parse, and a TF (term frequency) scoring algorithm that would make a CS undergrad shrug.

But it works. For the simple reason that project knowledge is mostly keywords and categories, not semantic embeddings. When the LLM asks "what's the architecture?", it doesn't need cosine similarity between a 1536-dimensional vector and the README. It needs a string match on the word "architecture" paired with the project:structure tag.

It auto-captures decisions on shutdown

When you close a session, pi-memoir scans the conversation for decisions, architecture changes, and important notes — and stores them automatically with an "auto" source tag. So even when you forget to /memo store "we decided to use Drizzle ORM instead of Prisma", the memoir remembers.

No more "wait, why did we switch databases?" scrolls through 3 hours of chat history "oh right, the connection pool issue."

Okay But How Do I Actually Use This?

1. Install pi

You need pi, the LLM-native coding agent. It's bun install -g @mariozechner/pi-coding-agent.

2. Install pi-memoir

pi install git:github.com/k1lgor/pi-memoir

Or, if you're the type who likes living on the edge:

pi install ./path/to/cloned/pi-memoir

3. Harvest your project

/memo harvest

Walk away. Make coffee. It takes ~2 seconds on a small project, ~30 seconds on TypeScript.

4. Work normally

That's it. The LLM now queries the memoir instead of running ls/grep/find. You'll see it in the logs:

🧠 [memo_search] Found 3 results for "architecture" (tags: project:structure)

And in your wallet:

💸 Token savings: 99.9% this session

Bonus: Benchmark your own project

The extension ships with a standalone bench script:

node bench.mjs . --all

📈 Summary
  Files scanned:    40,877
  Read files:       ~36,362,143 tokens
  Query memoir:    ~19,293 tokens
  Savings:          ~36,342,850 tokens (99.9%)

If you can't feel the dopamine rush from a 99.9% savings number, I don't know what to tell you.

What's Next?

The current version is already saving me ~$200/month in LLM costs. But here's what's cooking:

🔬 Semantic search via LLM re-ranking — for when keyword matching isn't enough
🕸️ Knowledge graph from cross-file relationships — imagine the memoir telling the LLM "this function depends on that module which is imported by this route"
📓 Obsidian vault export — because what's more developer than exporting a perfectly usable knowledge base into a note-taking app you'll abandon in 3 months

The One-Liner

If you use AI coding agents, you are paying for the same ls command 47 times a session. Pi-memoir replaces that with a cheap memory lookup.

It's one install command. It takes 2 seconds to harvest. It saves 95-99% of your project exploration tokens.

Install it. Harvest your project. Watch your token count crater.

P.S. — If you're still not convinced, run the benchmark against your own project. node bench.mjs . --all. I promise the number will make you smile.

P.P.S. — The name is "pi-memoir" but you can pronounce it however you want. I'm partial to "pee-mem-wah" like you're a very confused French person talking about urination. But "pie-memory" works too.

Built with ❤️ by k1lgor. Inspired by MemPalace (verbatim memory with semantic retrieval) and Graphify (knowledge graph extraction).

🧠 I Combined Two AI Powerhouse Skill Systems Into One Mega-Mind. Here's What Happened.

k1lgor — Fri, 06 Mar 2026 18:03:23 +0000

How I merged the discipline of Superpowers with the expertise of Virtual Company to create the ultimate AI coding companion.

The Problem: Too Many AI Personalities, Not Enough Flow

If you've been using AI coding assistants like GitHub Copilot, Cursor, or Antigravity IDE, you've probably felt this pain:

You ask for a bug fix, and the AI refactors your entire codebase.

You want a quick feature, and it skips the tests entirely.

You need architecture advice, and it just starts coding.

The problem isn't the AI—it's the lack of structured behavior. AI assistants are brilliant but chaotic. They need guardrails, workflows, and expertise routing.

That's why I went down the rabbit hole of combining two of the most sophisticated AI skill systems out there:

Superpowers (by obra): 13 core workflow skills focused on disciplined development
Virtual Company (by k1lgor): 27 domain expert skills for specialized tasks

The result? Mega-Mind — a unified skill system with 41 skills that brings order to the chaos.

What Makes These Systems Special?

Superpowers: The Discipline Framework

Superpowers isn't about what you code—it's about how you approach coding. It introduces structured workflows like:

brainstorming → writing-plans → test-driven-development →
executing-plans → verification-before-completion

Every feature goes through the same rigorous process. No more jumping straight to implementation without thinking.

Virtual Company: The Expert Team

Virtual Company treats your AI like a team of specialists:

tech-lead for architecture decisions
bug-hunter for debugging
security-reviewer for audits
docker-expert for containerization
ml-engineer for machine learning
...and 22 more domain experts

Instead of a generic AI, you get the right specialist for the job.

The Challenge: Two Systems, One Brain

Here's where it got interesting. These systems had different philosophies:

Superpowers	Virtual Company
Process-driven	Expertise-driven
Sequential workflows	Domain specialists
"Think before you code"	"Get the right expert"
13 workflow skills	27 domain skills

How do you combine process discipline with domain expertise?

The answer: Create an orchestrator that routes requests to the right skills and ensures they follow the right workflow.

Enter: The Mega-Mind Orchestrator

I created a master skill called /mega-mind that acts as the conductor of this orchestra:

┌───────────────────────────────────────────────────────┐
│                    /mega-mind                         │
│                (Master Orchestrator)                  │
│                                                       │
│   ANALYZE → ROUTE → EXECUTE → VERIFY → REPORT         │
└───────────────────────────────────────────────────────┘
                         ↓
              ┌─────────────────────┐
              │   Target Skill(s)   │
              └─────────────────────┘

How It Works

User says:

"I need to add user authentication with OAuth"

Mega-Mind responds:

🧠 Mega-Mind Orchestration
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📋 Request Analyzed: New feature - User Authentication with OAuth

🔄 Routed to skill chain:
   1. tech-lead          → Define architecture
   2. brainstorming      → Explore OAuth providers
   3. api-designer       → Design auth API
   4. writing-plans      → Create implementation plan
   5. test-driven-development → Write auth tests
   6. backend-architect  → Implement auth service
   7. frontend-architect → Implement login UI
   8. security-reviewer  → Security audit
   9. verification-before-completion → Verify

📍 Starting with: tech-lead

Notice how it:

Analyzes the request type (new feature)
Routes to the right skills in the right order
Includes domain experts (api-designer, security-reviewer)
Enforces workflow (brainstorming before planning, TDD, verification)

The Skill Routing Matrix

One of my favorite parts is the automatic routing. Here's the decision tree:

INCOMING REQUEST
       │
       ├─── Bug/Error? ───→ systematic-debugging → bug-hunter
       │
       ├─── New Feature? ───→ tech-lead → brainstorming → writing-plans
       │
       ├─── Performance? ───→ performance-profiler
       │
       ├─── Security? ───→ security-reviewer
       │
       ├─── DevOps? ───→ infra-architect → docker-expert → k8s-orchestrator
       │
       ├─── Data/ML? ───→ data-engineer → ml-engineer
       │
       └─── Documentation? ───→ doc-writer

No more guesswork. The system knows exactly which expert to call.

The Complete Skill Arsenal

13 Core Workflow Skills (Process Discipline)

Skill	Purpose
`brainstorming`	Explore approaches before committing
`writing-plans`	Create detailed implementation plans
`executing-plans`	Execute with progress tracking
`test-driven-development`	Write tests first, implement second
`systematic-debugging`	Root cause analysis methodology
`verification-before-completion`	Prove it works before "done"
`requesting-code-review`	Structured review requests
`receiving-code-review`	Handle feedback systematically
`finishing-a-development-branch`	Clean branch wrap-up
`using-git-worktrees`	Parallel development workflows
`single-flow-task-execution`	Sequential task decomposition
`using-mega-mind`	Skill routing logic
`writing-skills`	Create new custom skills

27 Domain Expert Skills (Specialized Knowledge)

Category	Skills
Architecture	tech-lead, frontend-architect, backend-architect, infra-architect, api-designer
Development	code-polisher, migration-upgrader, mobile-architect, legacy-archaeologist
Testing	test-genius, e2e-test-specialist, bug-hunter
DevOps	ci-config-helper, docker-expert, k8s-orchestrator, observability-specialist
Data/AI	data-engineer, data-analyst, ml-engineer, search-vector-architect
Security	security-reviewer
Performance	performance-profiler
Product	doc-writer, ux-designer, product-manager, workflow-orchestrator, skill-generator

Real-World Example: Bug Fix Flow

Let me show you how a simple bug report transforms into a rigorous fix:

Input:

"Users are randomly getting logged out"

Mega-Mind routing:

1. systematic-debugging
   → Reproduce the bug
   → Gather evidence
   → Form hypothesis

2. bug-hunter
   → Find root cause
   → Identify affected code

3. test-driven-development
   → Write regression test
   → Ensure bug is caught

4. verification-before-completion
   → Run all tests
   → Verify fix works
   → Check for side effects

5. finishing-a-development-branch
   → Clean commit
   → Ready to merge

The bug isn't just "fixed" — it's properly debugged, tested, verified, and documented.

The Anti-Patterns This Prevents

I built this system to stop the bad habits we've all fallen into:

❌ Skipping brainstorming for complex features
❌ Writing implementation before tests
❌ Marking tasks complete without verification
❌ Ignoring code review feedback
❌ Not documenting architectural decisions
❌ Using a generic approach for specialized tasks

Every workflow has quality gates. Every skill has a purpose. Every request follows a proven path.

Installation: One Command

I made installation as simple as possible for Antigravity IDE users:

# Clone and run
git clone https://github.com/k1lgor/mega-mind-skills.git
cd mega-mind-skills
./install.sh /path/to/your/project

Or just copy the .agent directory to your project root. That's it.

Run the validation to make sure everything's in place:

bash .agent/tests/run-tests.sh

What's Next?

I'm using Mega-Mind daily in my development workflow, and the difference is night and day. My AI assistant now:

Thinks before coding (brainstorming → planning)
Uses the right expert (security-reviewer for auth, docker-expert for containers)
Never skips tests (TDD is mandatory in the workflow)
Verifies everything (no more "it works on my machine")

The code quality has improved. The bug count has dropped. And I spend less time correcting AI mistakes.

Try It Yourself

The entire system is open source and MIT licensed. All 41 skills, 6 workflows, 3 agent profiles, and the orchestrator are yours to use.

📁 GitHub: mega-mind-skills
📖 Documentation: Included in the repo
🧪 Tests: 58 automated validation tests

Your Turn

Have you tried structured AI skill systems? Do you use Superpowers, Virtual Company, or something else?

I'd love to hear how you're bringing discipline to your AI-assisted development workflow. Drop a comment below! 👇

If you found this helpful, give it a ❤️ and follow for more AI development content!

Аз Съм Спартак! — The Pulse of a Football Community

k1lgor — Sat, 28 Feb 2026 10:22:28 +0000

This is a submission for the DEV Weekend Challenge: Community

🦅 The Community

I built this project for the community of FC Spartak Varna ("The Falcons"), one of Bulgaria's most historic football clubs. Currently, the club and its supporters are united in a massive fundraising campaign titled "Аз Съм Спартак" (I Am Spartak). The goal is to clear legacy debts and ensure the stable future of the club. This community is defined by intense loyalty, resilience, and a deep connection to their city and heritage.

What I Built

I created a premium, minimalist landing page designed to drive engagement for the fundraising campaign. Instead of a typical "salesy" interface, I focused on high-end aesthetics and emotional impact:

"Heartbeat" Loading Screen: An animated entry sequence that pulses with the phrase "Аз... Съм... СПАРТАК!" (I... Am... SPARTAK!) to build an immediate emotional bond.
Cinematic Identity: A custom-designed background integrating the official 1918 club logo with a powerful falcon silhouette.
Minimalist Tiers: A clean, two-column layout presenting the donation levels (€200 and €500) and their specific community rewards (The Wall of Honor, Gold Letters in history).
Functional IBAN Integration: A seamless copy-to-clipboard feature for bank transfers.

Demo

Дарения за ФК Спартак Варна | Кампания „Аз съм Спартак“

Подкрепете ФК Спартак Варна с дарителска карта, свободно дарение или банков превод. Вижте пакетите, банковите детайли и начините за подкрепа.

azsamspartak.fan

Code

You can find the full source code, built with performance and clean design in mind, here:

k1lgor / azsamspartak

Kампания за набиране на средства за ФК Спартак Варна. Аз съм Спартак!

🦅 Аз Съм Спартак (I am Spartak) - Fundraising Landing Page

A premium, minimalist landing page built for FC Spartak Varna's official fundraising campaign.

⚽ The Mission

FC Spartak Varna is one of Bulgaria's most storied football clubs. This landing page aims to unify the community ("The Falcons") to clear heritage debts and secure the club's stable future. The campaign, titled "I Am Spartak", focuses on high-impact donations through donation cards and community support.

✨ Features

Emotional Loading Screen: A custom "Heartbeat" animation triggering the "Аз... Съм... СПАРТАК!" (I... Am... SPARTAK!) narrative.
Cinematic Visuals: A high-end background featuring a falcon silhouette integrated with the original club logo.
Minimalist Design: A clean, distraction-free interface focusing on the donation tiers and the mission.
Donation Tiers:
- 🔹 Standard (€200)
- 🔹 Premium (€500) - includes the "Wall of Honor" and "Golden Letters" in club history.
- 🔹 Free donation choice.
Functional IBAN Details:…

View on GitHub

How I Built It

I wanted the site to be as fast and "lightweight" as a falcon, so I kept the tech stack modern and dependency-free:

React 19 & Vite: For a blazing-fast core and modern component architecture.
Bun: Used as the package manager and runtime for ultra-fast development cycles.
Vanilla CSS: No heavy UI libraries. I used CSS Grid for the responsive layout, CSS Animations for the heartbeat effect, and Glassmorphism to ensure text readability over the cinematic background.
Lucide-React: For crisp, minimalist iconography.

This project shows how modern web design can serve local sports communities by turning a simple call for donations into a premium brand experience.

Built by @k1lgor — Semper 1918 Fidelis 🔵🦅⚪️

🏥 RepoDoctor - AI-Powered Repository Health Analysis with GitHub Copilot CLI

k1lgor — Thu, 12 Feb 2026 20:17:51 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

RepoDoctor - Your Repository's AI Doctor 🩺

RepoDoctor is a Copilot-first CLI tool that revolutionizes how developers analyze and maintain their codebases. Instead of relying on rigid, hardcoded rules like traditional static analysis tools, RepoDoctor acts as an intelligent orchestrator that delegates all analysis logic to GitHub Copilot CLI.

Think of it as having an AI-powered code doctor that:

🍔 Diagnoses bloat - Identifies large files, build artifacts, and missing hygiene files
🌎 Creates onboarding guides - Generates comprehensive TOUR.md files for new contributors
🐳 Audits Dockerfiles - Provides security and optimization recommendations
💀 Detects dead code - Finds unused code with confidence levels
🔬 Performs health scans - Multi-module analysis with overall health scoring
📋 Generates reports - Beautiful markdown reports from scan results

What makes RepoDoctor special?

Traditional tools like ESLint, Pylint, or SonarQube use static rules that can't understand context. They tell you what's wrong but not why or how to fix it in your specific situation.

RepoDoctor is different because:

✅ Contextual AI Analysis - Understands your tech stack, project structure, and patterns
✅ Actionable Recommendations - Not just "this is bad," but "here's how to improve it"
✅ Zero Configuration - No complex rule files or configuration needed
✅ Extensible Prompts - Easy to add new analysis types with prompt templates
✅ Human-Readable Output - Generates documentation, not just error lists

Why it matters to me:

As a developer, I've spent countless hours:

Onboarding new team members who struggle to understand large codebases
Debugging performance issues caused by bloated repositories
Reviewing PRs with potential security issues in Docker configurations
Hunting for dead code that clutters the codebase

RepoDoctor solves these pain points by leveraging AI to provide intelligent, context-aware analysis that actually helps developers improve their code quality.

Project Links

GitHub Repository: https://github.com/k1lgor/RepoDoctor
PyPI Package: https://pypi.org/project/repodoc/
Documentation: https://github.com/k1lgor/RepoDoctor/blob/main/README.md

Demo

Quick Installation & Usage

# Install from PyPI
pip install repodoc

# Install from uv
uv install repodoc

# Use repodoc without installation
uv tool run repodoc

# Analyze repository bloat
repodoc diet

# Generate onboarding guide
repodoc tour

# Run full health scan
repodoc scan

# Generate beautiful report
repodoc report

My Experience with GitHub Copilot CLI

Building RepoDoctor was a transformative experience that fundamentally changed how I approach software development. GitHub Copilot CLI wasn't just a tool I used—it became the core architecture of my entire application.

The Copilot-First Architecture

Instead of building traditional static analysis with hardcoded rules, I had a radical idea: What if the AI itself is the analysis engine?

This led to RepoDoctor's unique architecture:

Prompt Templates - Each analysis type (diet, tour, docker, etc.) has a carefully crafted prompt
Workflow Orchestration - RepoDoctor manages file discovery, data collection, and output formatting
AI Delegation - All actual analysis logic is delegated to GitHub Copilot CLI
Schema Validation - Pydantic schemas ensure the AI returns structured, reliable data

How I Used GitHub Copilot CLI

1. Prompt Engineering as Code

I created a sophisticated prompt template system that provides Copilot CLI with:

Context - File listings, directory structure, key metrics
Instructions - Clear objectives and output format requirements
Constraints - What to focus on, what to ignore
Examples - Sample outputs to guide the AI

2. Iterative Development with Copilot CLI

During development, Copilot CLI helped me:

Code Generation:

Generated boilerplate for CLI commands with Typer
Created Pydantic schemas for each analysis type
Built async orchestration code for subprocess management

Debugging:

# When tests failed, I asked Copilot:
copilot "Why is this pytest fixture not mocking shutil.which correctly?"
copilot "How do I handle UTF-8 encoding on Windows for subprocess output?"

Architecture Decisions:

copilot "Should I use sync or async for subprocess calls to GitHub Copilot CLI?"
copilot "What's the best way to cache analysis results for the report command?"

3. AI-Powered Documentation Generation

The tour command is my favorite feature—it uses Copilot CLI to generate comprehensive onboarding guides by analyzing:

Project structure
Code patterns
Tech stack
Dependencies
Common workflows

This would have taken hours to write manually, but Copilot CLI generates it in seconds with context-aware understanding of the codebase.

Leveraging Agent Skills

One of my secret weapons during development was my Virtual Company project—a collection of 27 specialized agent skills that enhance AI agents with domain-specific expertise.

These skills act as expert personas that guide GitHub Copilot CLI through complex workflows.

These skills transformed GitHub Copilot CLI from a general assistant into a team of specialized experts, each bringing deep domain knowledge to different aspects of the project. It's like having a senior developer, tech writer, QA engineer, and DevOps specialist all working together!

Virtual Company is open source: https://github.com/k1lgor/virtual-company

Impact on My Development Experience

Before GitHub Copilot CLI:

❌ Spent hours writing static analysis rules
❌ Struggled with complex regex patterns
❌ Wrote boilerplate code manually
❌ Context-switched between docs and coding

With GitHub Copilot CLI + Virtual Company Skills:

✅ 10x faster development - Instant code generation and debugging
✅ Expert-level guidance - Each skill provides specialized domain knowledge
✅ Better architecture - Copilot with tech-lead skill suggested async patterns I wouldn't have considered
✅ Fewer bugs - AI-reviewed code with bug-hunter skill before I even ran it
✅ More creativity - Spent time on features, not implementation details
✅ Continuous learning - Copilot taught me new Python patterns and best practices
✅ Comprehensive testing - Test-genius skill helped achieve 48 passing tests with proper mocking

The Meta Experience

The most mind-bending part? I built a tool powered by GitHub Copilot CLI, while using GitHub Copilot CLI to build it. 🤯

It was like:

Using Copilot CLI to debug Copilot CLI integration
Asking Copilot to generate prompts for Copilot
Having Copilot help me test code that invokes Copilot

This recursive AI-assisted development felt like a glimpse into the future of software engineering.

Key Takeaways

AI-First Architecture is Real - RepoDoctor proves you can build production tools with AI as the core logic engine
Prompt Engineering Matters - The quality of your prompts directly impacts output quality
Specialized Skills Amplify AI - Using domain-specific agent skills (Virtual Company) accelerates development exponentially
Copilot CLI for Everything - From code generation to debugging to documentation
Ship Faster, Iterate Smarter - Copilot CLI enabled rapid prototyping and validation
The Future is AI-Native - Tools will increasingly delegate intelligence to AI rather than hardcode it

Try RepoDoctor Today!

uv install repodoc
cd your-project
repodoc scan

GitHub: https://github.com/k1lgor/RepoDoctor

PyPI: https://pypi.org/project/repodoc/

Built with ❤️ and 🤖 by @k1lgor using GitHub Copilot CLI

Solving the Knapsack Problem - A Guide to Dynamic Programming

k1lgor — Thu, 11 May 2023 20:05:25 +0000

Introduction

The Knapsack problem is a well-known optimization problem in computer science. Given a set of items, each with a weight and a value, the problem is to select a subset of the items that maximizes the total value while keeping the total weight below a certain limit. The problem gets its name from the idea of packing a knapsack with items of varying sizes and values.

The Knapsack problem is a classic example of a dynamic programming problem, which means that we can solve it efficiently by breaking it down into smaller subproblems and combining the solutions to those subproblems to find the optimal solution.

Dynamic Programming Solution

The key idea behind the dynamic programming solution to the Knapsack problem is to build a table (often called a "DP table") where each cell represents the optimal value for a particular combination of items and weights. The table is initialized with zeros, and then filled in using a recursive formula.

In the recursive formula, we consider each item in turn, and for each item, we consider all possible weights up to the maximum weight. If the weight of the current item is greater than the current weight, we cannot include the item, so we simply use the value from the previous row in the table. If the weight of the current item is less than or equal to the current weight, we have a choice: we can either include the item, in which case we add its value to the value of the optimal solution for the remaining weight, or we can exclude the item, in which case we simply use the value from the previous row in the table.

After filling in the entire table, we can use it to backtrack and find the selected items that give us the maximum value. Starting from the bottom right corner of the table, we check each cell to see if its value is different from the value in the cell above it. If it is, that means we included the item corresponding to that row in the optimal solution, so we add it to our list of selected items and move to the cell in the previous row with the remaining weight.

The Python Implementation

Here is a Python implementation of the Knapsack algorithm using dynamic programming:

def knapsack(items, max_weight):
    # Initialize a 2D array with zeros
    dp_table = [[0 for _ in range(max_weight + 1)] for _ in range(len(items) + 1)]

    # Fill the table with the optimal values for each weight and item combination
    for i in range(1, len(items) + 1):
        weight, value = items[i - 1]
        for w in range(1, max_weight + 1):
            if weight > w:
                dp_table[i][w] = dp_table[i -1][w]
            else:
                dp_table[i][w] = max(dp_table[i - 1][w], dp_table[i -1][w - weight] + value)
    # Backtrack to find the selected items
    selected_items = []
    w = max_weight
    for i in range(len(items), 0, -1):
        if dp_table[i][w] != dp_table[i - 1][w]:
            selected_items.append(items[i - 1])
            w -= items[i -1][0]

    # Return the total value and selected items
    return dp_table[-1][-1], selected_items


def main():
    items = [(2, 3), (3, 4), (4, 5), (5, 6)]
    max_weight = 8

    total_value, selected_items = knapsack(items, max_weight)

    print("Total value:", total_value)
    print("Selected items:", selected_items)


if __name__ == "__main__":
    main()

The knapsack function takes two arguments: a list of items, where each item is represented as a tuple of the form (weight, value), and a maximum weight. The function returns a tuple containing the total value of the selected items and the list of selected items themselves.

We have four items with weight and values (2, 3), (3, 4), (4, 5), and (5, 6). We want to find the subset of items that maximizes the total value while keeping the total weight below 8. Running the knapsack function with these arguments gives us the following output:

Total value: 10
Selected items: [(5, 6), (3, 4)]

This means that the optimal subset of items has a total value of 10, and consists of the items with weight and values (5, 6) and (3, 4).

Conclusion

The Knapsack problem is a classic optimization problem that can be efficiently solved using dynamic programming. The key idea is to build a table that represents the optimal value for each combination of items and weights, and then fill it in using a recursive formula. The resulting table can be used to backtrack and find the selected items that give us the maximum value.

In this article, I have shown how to implement the Knapsack algorithm in Python using dynamic programming, and provided an example of how to use it. While this implementation is relatively simple, there are many variations of the Knapsack problem with different constraints and objectives, and more sophisticated algorithms may be needed to solve them efficiently.

Thank you for reading 🧑‍💻

Stay tuned for more 🚀

✌️ and logout

Understanding Linux Commands - A Comprehensive Guide

k1lgor — Sat, 22 Apr 2023 11:38:18 +0000

Introduction

If you’re new to Linux or have recently switched to it, you may have been overwhelmed by the vast array of commands you can use within it. These commands have a different syntax than those you might be used to in Windows or Mac systems; however, once you have an understanding of how they work, using Linux commands becomes easy and straightforward.

In this article, we’ll provide you with a comprehensive guide on complex Linux commands. We’ll explain what they are, how they work, and how you can use them to optimize your work processes. Let's get started!

What are Linux Commands?

Linux commands are text-based instructions that you can use within a Linux terminal. They can help you to execute specific tasks and communicate with your computer's operating system. The terminal is a text-based interface that you can access by typing in specific commands. You can achieve several tasks, such as copying files, starting programs, or updating your system, using only commands.

Basic Linux Commands

Let’s begin with some basic commands. These commands are used frequently and are an essential part of mastering the Linux terminal.

ls: This command lists all the files and directories in your current location. You can use the -a option to display hidden files, and the -l option to display them in long format.
cd: The cd command is used to change directories. For example, cd Downloads will take you to the Downloads directory.
pwd: This command displays the working directory in your terminal.
mkdir: The mkdir command is used to make a new directory. For example, to create a folder called ‘test’, you can use the command mkdir test.
rm: The rm command is used to remove files, and it's often used with the -rf option to remove directories.
cp: This command is used to copy files and directories from one location to another.
mv: This command is used to move files and directories from one location to another.

Intermediate Linux Commands

Now that you are familiar with some basic Linux commands let's look at a few intermediate level commands to enhance your Linux knowledge.

grep: This command is used to search for a specific word or pattern within a file. For example, to look for the word ‘example’ in a file called ‘file.txt’, you can run the command grep example file.txt.
find: The find command is used to search through a directory's contents recursively. You can use it with different options such as -name to specify filenames or -size to search for specific file sizes.
ps: The ps command lets you view the currently running processes on your system. You can use it with different options such as -ef to display all processes.
wget: The wget command lets you download files from the internet. For example, to download a file called test.txt, you can use wget https://www.example.com/test.txt.

Advanced Linux Commands

Here are few advanced Linux commands that are rarely used but can be helpful in certain situations.

dd: The dd command is used to copy and convert data. For example, to create a bootable USB drive using an ISO file, you can use the command sudo dd if=path/to/iso of=/dev/sdb bs=4M; sync. Make sure to use the correct input and output file locations.
tar: The tar command is used to create compressed archives. For example, to create a .tar.gz archive of all files in the current directory, you can use the command tar -czvf archive_name.tar.gz *.
awk: The awk command is used to manipulate text files. For example, to print the first column of a tab-separated values file, you can run the command awk -F'\t' '{print $1}' file.txt.

Security-focused Linux Commands

Linux commands are powerful tools that can be used to perform various security-focused tasks such as user management, file permissions, and network security. In this section, we will take a look at some of the most commonly used security-focused Linux commands.

chmod: This command is used to change the permissions of a file or directory. The permissions can be specified using a numerical code or a symbolic code.
passwd: This command is used to change the password of a user account. The user is prompted to enter their old password, followed by their new password.
sftp: This command is used to securely transfer files over the network. It uses the SSH protocol to encrypt the data being transferred.
iptables: This command is used to manage network security by setting up rules for incoming and outgoing traffic. It can be used to block specific IP addresses or protocols.
ssh: This command is used to establish a secure remote connection to another computer. It uses the SSH protocol to encrypt the data being transferred.

By using these security-focused Linux commands, you can help protect your computer and network from potential security threats.

Conclusion

Linux commands can seem intimidating, but once you know how they work, they become extremely useful tools. We hope this guide provided a good starting point for mastering Linux commands. Keep practicing, and you'll soon be using Linux like a pro!

If you want to learn more about Linux, check out the Linux Documentation Project or join the Linux subreddit to connect with other users. Happy coding!

Thank you for reading 🧑‍💻

Stay tuned for more 🚀

✌️ and logout

Mastering the ssh Command - Tips and Tricks

k1lgor — Sun, 09 Apr 2023 15:29:53 +0000

Introduction

If you've ever needed to remotely access another computer, then you're probably familiar with the 'ssh' command. This powerful tool is used to securely connect to and manage remote systems, and it can be incredibly helpful for system administrators, developers, and anyone who needs to work on a remote machine. In this blog post, we'll explore some tips and tricks for using the 'ssh' command like a pro.

Basic Usage

Before we dive into some more advanced features, let's review the basic usage of the ssh command. To establish an SSH connection, simply type:

ssh username@hostname

Replace username with your username on the remote system, and hostname with the IP address or domain name of the remote system. You may also need to specify a port number using the -p flag if the SSH server is running on a non-standard port.

Once you enter this command, you'll be prompted to enter your password for the remote system. If everything goes well, you'll be connected to the remote machine and can start running commands as if you were logged in locally.

Advanced Usage

Now that we've covered the basics, let's take a look at some more advanced features of the ssh command.

Publick Key Authentication

Typing in your password every time you want to connect to a remote system can be a hassle, but luckily ssh supports public key authentication. This allows you to log in without typing your password, as long as you have a public key installed on the remote system. Here's how to set it up:

Generate a public/private key pair on your local machine using the ssh-keygen command. Make sure to keep your private key safe and secure.
Copy your public key to the remote system using the ssh-copy-id command. This will automatically add your public key to the remote system's authorized keys list.
Now, when you connect to the remote system, you should be able to log in without typing your password.

Proxying Connections

Sometimes, you may need to connect to a remote system through an intermediate server. This is where proxying comes in handy. To set up a proxy connection, use the -J flag followed by the hostname of the intermediate server:

ssh -J username@intermediate_host username@destination_host

This will establish a connection to the intermediate server first, and then to the final destination.

Port Forwarding

Port forwarding is a way to forward network traffic from one port on your local machine to a port on a remote machine, through an SSH tunnel. This can be incredibly helpful for accessing services that are not available directly from your local network. Here's an example:

ssh -L 8080:localhost:80 username@remote_host

This will forward all traffic from port 8080 on your local machine to port 80 on the remote host. Now, if you open a web browser on your local machine and navigate to localhost:8080, you'll see the website that's hosted on the remote machine.

Conclusion

The ssh command is a powerful tool that can be incredibly helpful for managing remote systems. By mastering some of the advanced features we've covered in this blog post, you'll be able to work more efficiently and securely on remote machines. Whether you're a system administrator or a developer, understanding the ssh command is an essential skill for anyone who needs to work with remote systems.

Thank you for reading 🧑‍💻

Stay tuned for more 🚀

✌️ and logout

Mastering the Powerful Linux Command - rsync

k1lgor — Sat, 01 Apr 2023 13:21:15 +0000

As a Linux user, you are already familiar with basic commands like ls, cd, and rm. But have you ever heard of rsync? It's one of the most powerful and versatile commands in Linux, and it can save you a lot of time and effort when working with large files and directories. In this post, we'll dive deep into the world of rsync and show you how to yse it to its full potential.

Introduction

Before we get started, let's talk about what rsync actually is. Rsync stands for "remote synchronization", and it's a command-line utility that allows you to copy files and directories between different locations, either on the same computer or over a network.

What makes rsync so powerful is its ability to transfer only the parts of files that have changed, rather than copying the entire file every time. This means that rsync can save you a lot of time and bandwidth when transferring large files, especially over slow or unreliable connections.

Basic Usage

The basic syntax for using rsync is simple:

rsync source destination

For example, if you want to copy all the files in the directory /home/user/Documents to /mnt/backup, you would use the following command:

rsync /home/user/Documents /mnt/backup

By default, rsync will copy all files and subdirectories from the source directory to the destination directory.

Advanced Usage

While the basic usage of rsync is straightforward, there are many advanced options that can help you fine-tune the way rsync works. Here are some of the most useful options:

--recursive: This option tells rsync to opy all files and subdirectories recursively, including any empty directories.
--delete: This option tells rsync to delete any files in the destination directory that are not present in the source directory. This is useful for keeping two directories in sync.
--progress: This options shows the progress of the file transfer in real-time, which can be useful when transferring large files.
--exclude: This option allows you to exclude certain files or directories from the transfer. For example, if you want to exclude all files with the extention .log, you would use the following command:

rsync --exclude '*.log' source destination

Tips and Tricks

Here are some additional tips and tricks to help you get the most out of rsync:

Always use the -v option for verbose output. This will help you see exactly what rsync is doing during the transfer.
Use the -h option to display file sizes in a human-readable format (e.g., "10MB" instead of "10485760")
If you are transferring a large number of files, consider using the --partial option, which allows rsync to resume interrupted transfers.
If you are transferring files over a network, use the -z option to enable compression, which can save you bandwidth.

Conclusion

Rsync is a powerful and versatile command that can help you save time and effort when working with large files and directories. Whether you are transferring files over a network or backing up your data to an external drive, rsync has the tools you need to get the job done. With the tips and tricks we've covered in this post, you'll be able to use rsync to its full potential and become a master of this powerful Linux command.

Thank you for reading 🧑‍💻

Stay tuned for more 🚀

✌️ and logout

Navigating Your Linux System with the cd Command

k1lgor — Sun, 26 Mar 2023 15:46:22 +0000

As a Linux user, navigating through the file system is an essential part of your daily routine. You may find yourself constantly moving from one directory to another in the terminal. That's where the cd command comes in handy. In this blog post, we'll take a deep dive into the cd command, its different options, and some practical examples to help you navigate through your Linux system with ease.

Basic Usage

The cd command stands for "change directory", and it's used to move from one directory to another. The basic syntax of the command is as follows:

cd [directory]

Where directory is the path to the directory you want to move into. For example, to move into the home directory, you can use the command:

cd ~

Or simply:

cd

Which takes you to your home directory.

Moving Up and Down the Directory Tree

In addition to moving into a specific directory, you can also move up and down the directory tree using the cd command. To move up one directory level, use the command:

cd ..

This command takes you to the parent directory of the current directory you're in. You can repeat the command to move up multiple levels at once. For example, if you're in the directory /home/user/Documents/projects/, the command:

cd ../../../

Will take you up three levels to the /home/user/ directory.

To move down the directory tree, you can use the cd command followed by the directory name. For example, to move from the home directory to the documents directory, use the command:

cd Documents

Useful Options

The cd command comes with some useful options that can make navigating through your Linux system even more efficient. Here are a few:

-P (or --physical) option: This option makes the cd command follow symbolic links, so you end up in the physical directory. For example, if you have a symbolic link mylink that points to /home/user/mydir, the command:

cd -P mylink

Will take you to the /home/user/mydir directory, rather than the directory where the symbolic link is located.

-L (or --logical) option: This option is the opposite of the -P option. It makes the cd command follow symbolic links, so you end up in the logical directory. For example, using the same symbolic link mylink as above, the command:

cd -L mylink

Will take you to the directory where the symbolic link is located, rather than the directory it points to.

Tips and Tricks

Use tab completion: The cd command supports tab completion, which can save you time and prevent typing errors. Simply type the first few letters of the directory name, then press the tab key to complete it.
Use cd with other commands: You can use the cd command with other Linux commands to perform operations in a specific directory. For example, to list the files in the documents directory, use the command:

cd Documents && ls

This command first moves you to the documents directory, then lists its contents using the ls command.

Use absolute paths: Instead of typing the entire path to a directory, you can use the absolute path to save time. For example, instead of typing:

cd /home/user/Documents/projects/project1

You can use:

cd ~/Documents/projects/project1

This takes you to the same directory but is shorter and easier to type.

Conclusion

In conclusion, the cd command is a powerful tool that allows you to navigate your file system with ease. By understanding how to use this command effectively, you can save time and improve your productivity when working on the command line. Remember to use absolute or relative paths depending on your needs, and take advantage of the ~ and - shortcuts to quickly navigate to frequently accessed directories. Additionally, always pay attention to the output of the cd command to ensure that you are moving to the correct directory. With these tips and tricks in mind, you'll be a cd command pro in no time!

Thank you for reading 🧑‍💻

Stay tuned for more 🚀

✌️ and logout

Mastering Text Manipulation with the Cut Command in Linux

k1lgor — Sun, 26 Mar 2023 15:16:01 +0000

Introduction

When it comes to working with Linux, the command line is a powerful tool that can make your life much easier. While there are many commands available, one that is particularly useful for manipulating text data is cut.

The Power of cut

The cut command is used to extract specified sections from each line of a file or input. By default, cut extracts every character from the beginning to the end of each line. However, it can be used to extract specific fields, columns or sections of a line based on a delimiter or a character position.

Examples

For example, suppose we have a file called data.txt that contains the following lines of data:

John,Smith,25,USA
Maria,Garcia,32,Mexico
Ahmed,Khan,45,Pakistan

If we want to extract only the first names, we can use the following command:

cut -d',' -f1 data.txt

This tells cut to use the comma , as the delimiter and extract only the first field of each line, which contains the first name. The output will be:

John
Maria
Ahmed

We can also use cut to extract a range of characters from each line. For example, to extract only the first three characters of each line from our data.txt file, we can use the following command:

cut -c1-3 data.txt

This will output:

Joh
Mar
Ahm

Another useful feature of cut is the ability to extract a specific column from a file that does not use a delimiter. For example, suppose we have a file called numbers.txt that contains the following data:

1234
5678
9101

To extract the second column (i.e., the second digit of each number), we can use the following command:

cut -c2 numbers.txt

This will output:

2
6
1

Tips

Here are some additional tips for using the cut command:

To extract the last field of each line, use the -f option with a negative value. For example, to extract the countries from our data.txt file, we can use the following command:

cut -d',' -f4 -s data.txt

The -s option tells cut to suppress lines that do not contain the delimiter.

To extract a range of characters from each line using a specific delimiter, use the -d option followed by the delimiter and the -c option followed by the starting and ending character positions. For example, suppose we have a file called emails.txt that contains the following data:

john.smith@example.com
maria.garcia@example.com
ahmed.khan@example.com

To extract only the domain names (i.e., the text after the @ symbol) from each line, we can use the following command:

cut -d'@' -f2 emails.txt | cut -d'.' -f1

This will output:

example
example
example

Conclusion

With the cut command, you can quickly and easily manipulate text data in Linux. Whether you need to extract specific fields from a file, extract a range of characters from each line, or extract a specific column from a file that does not use a delimiter, cut is a powerful tool that can save you time and effort. So next time you're working with text data in Linux, be sure to give cut a try!

Thank you for reading 🧑‍💻

Stay tuned for more 🚀

✌️ and logout

Efficiently Managing Processes with the ps Command in Linux

k1lgor — Thu, 23 Mar 2023 16:52:18 +0000

Introduction

The ps command is a powerful tool in Linux that allows you to monitor and manage processes on your system. Whether you need to identify a specific process, check the resource usage of a program, or kill a process that's misbehaving, the ps command has you covered.

Using the `ps` Command

At its simplest, the ps command allows you to view information about the processes running on your system. For example, you can use the ps command with no options to display a list of all the processes running on your system:

ps

The above command will display a list of all the processes currently running on your system. By default, the ps command will display the process ID (PID), the terminal associated with the process, the CPU usage, and the command that started the process

Options and Customization

While the basic ps command is useful, there are many options and customization features that you can use to tailor the output to your specific needs. For example, you can use the -e option to display information about all processes on the system, regardless of who owns them:

ps -e

Another useful option is the -f option, which displays a more detailed output that includes the UID, PPID, C, STIME, TTY, and TIME fields:

ps -f

Tips and Tricks

You can use the grep command to search for specific processes. For example, to search for all processes containing the word "chrome", you can use the following command:

ps -ef | grep brave

You can use the kill command to terminate a process. For example, to kill a process with a specific PID, you can use the following command:

kill PID

And you choose the PID number.

Show all processes with full information:

ps -ef

Show all processes with full information and a tree-like format:

ps -ejH

Show all processes with full information and a BSD-style format:

ps axo pid,tt,user,fname,tmout,f,wchan

Show all processes with full information and display the username and start time:

ps -eo user,pid,ppid,c,start_time,cmd

Show all processes with full information and display the threads for each process:

ps -eLf

Show all processes with full information and display the start time and elapsed time for each process:

ps -eo pid,comm,lstart,etime

Show all processes with full information and sort by memory usage (descending):

ps -e --sort=-rss

Show all processes with full information and display only the processes owned by a specific user:

ps -u username

Show all processes with full information and display only the processes with a specific name:

ps -C program_name

Show all processes with full information and display only the processes with a specific PID:

ps -p PID

You can use the top command to view a dynamic real-time display of the processes running on your system.

Conclusion

The ps command is a powerful and essential tool in Linux for monitoring and managing processes. With its simple syntax and powerful options, you can quickly identify, monitor, and manage processes on your system. Whether you're a system administrator, developer, or power user, the ps command is a must-know tool for efficient Linux management.

Thank you for reading 🧑‍💻

Stay tuned for more 🚀

✌️ and logout