server-management
Master the thinking behind running production servers rather than memorizing commands. This skill covers process management tool selection, monitoring strategy across availability and performance, log rotation principles, and scaling decisions. You'll learn health check implementation, security practices, and a structured troubleshooting priority system to diagnose server issues.
Server Management teaches production operations principles, process management, monitoring strategy, and scaling decision-making.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-26
Server Management teaches production operations principles, process management, monitoring strategy, and scaling decision-making. Master the thinking behind running production servers rather than memorizing commands. This skill covers process management tool selection, monitoring strategy across availability and performance, log rotation principles, and scaling decisions. You'll learn health check implementation, security practices, and a structured troubleshooting priority system to diagnose server issues.
Use it when
- server-management covers scaling decision frameworks by teaching you to analyze your bottleneck first.
- server-management covers process manager selection and configuration for auto-restart reliability.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Similar skills
Install
vudovn/ag-kit/server-management · repository language: TypeScript
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How do you manage servers in production?
server-management teaches a decision-making framework for production operations rather than rote commands. Core practices include selecting appropriate process managers (PM2, systemd, or alternatives), implementing health checks and monitoring for availability and performance metrics, establishing log rotation to prevent disk issues, and using structured troubleshooting to diagnose problems systematically. The skill emphasizes understanding *why* each practice matters so you can adapt to your specific infrastructure needs.
When should you scale your application horizontally or vertically?
server-management covers scaling decision frameworks by teaching you to analyze your bottleneck first. Vertical scaling (bigger servers) suits single-threaded workloads or database-bound applications; horizontal scaling (more servers) works best for stateless services handling traffic spikes. The skill trains you to monitor CPU, memory, and I/O patterns, then choose the approach that matches your application's architecture and cost constraints.
What process management best practices should you follow?
server-management covers process manager selection and configuration for auto-restart reliability. Key practices include choosing between PM2 for Node.js applications or systemd for system-level services, configuring automatic restarts on crashes, setting resource limits to prevent runaway processes, and integrating with your monitoring strategy. The skill teaches you to evaluate tools based on your deployment environment and application requirements.
How do you design a server monitoring and alerting strategy?
server-management teaches monitoring strategy by identifying what metrics matter: availability (uptime checks), performance (CPU, memory, I/O), and application-specific signals. You'll learn health check implementation patterns, log management principles including rotation to prevent disk exhaustion, and how to prioritize alerts to avoid noise. The skill emphasizes building a coherent strategy rather than collecting every possible metric.
What troubleshooting approach works for server issues?
server-management provides a structured troubleshooting priority system: first check process status and logs, then examine resource utilization (CPU, memory, disk), then investigate network connectivity and dependencies. The skill teaches log management best practices like rotation and retention policies, and how to correlate symptoms across multiple data sources to identify root causes efficiently.
How do you implement zero downtime deployment and reliability patterns?
server-management covers reliability patterns including health checks that enable graceful restarts, process manager configurations that coordinate rolling updates, and monitoring strategies that detect deployment issues early. The skill teaches security principles for production environments and how these practices work together to maintain uptime during updates and handle traffic spikes without service interruption.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Server Management
> Server management principles for production operations. > Learn to THINK, not memorize commands.
1. Process Management Principles
Tool Selection
| Scenario | Tool |
|---|---|
| Node.js app | PM2 (clustering, reload) |
| Any app | systemd (Linux native) |
| Containers | Docker/Podman |
| Orchestration | Kubernetes, Docker Swarm |
Process Management Goals
| Goal | What It Means |
|---|---|
| Restart on crash | Auto-recovery |
| Zero-downtime reload | No service interruption |
| Clustering | Use all CPU cores |
| Persistence | Survive server reboot |
2. Monitoring Principles
What to Monitor
| Category | Key Metrics |
|---|---|
| Availability | Uptime, health checks |
(truncated - see the full file via the links below)
File tree — 1 file
.agents/skills/server-management/SKILL.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Learn server management principles and decision-making frameworks”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Master the core principles of mobile game development, from touch interface design and performance tuning to navigating platform constraints. This skill covers battery and thermal management strategies, responsive UI patterns, and the specific requirements of iOS and Android app stores. Build games that respect mobile hardware limits while delivering smooth, engaging experiences.
Database Design teaches schema fundamentals, ORM selection, and performance tuning through structured decision-making rather than rote patterns. It covers normalization, relationship design, indexing strategy, and query optimization across PostgreSQL, SQLite, and serverless databases.
This skill guides you through principled decisions for Node.js development—from picking the right framework (Express, Fastify, NestJS, Hono) based on your deployment target and performance needs, to structuring layered architectures and handling errors consistently. It covers async patterns, validation strategies, security fundamentals, and testing priorities, emphasizing context-aware choices over one-size-fits-all solutions.
Architecture guides decision-making through requirements analysis, trade-off evaluation, and ADR documentation. It helps teams capture design rationale and choose patterns systematically, emphasizing simplicity and constraint-aware choices.
mcp-builder covers the essentials of building Model Context Protocol servers, from project structure and transport selection to tool and resource design. It walks through input validation, error handling, multimodal support, and configuration patterns for both local and remote deployments. Follow the included checklist to ensure your server is well-documented, secure, and ready for production use.
Learn the essentials of game design through core loop mechanics, game design document structure, and player motivation frameworks. This skill covers difficulty balancing, progression design, and practical anti-patterns to avoid during development. Build engaging games by understanding the 30-second loop, reward systems, and flow state principles.