Core dump analysis skill for production crash triage. An agent skill from mohitmishra786/low-level-dev-skills.

MITAuto-check: notesDevelopment

Install Core Dumps

skills CLI
$ npx skills add mohitmishra786/low-level-dev-skills --skill core-dumps -a claude-code

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

GitHub CLI
$ gh skill install mohitmishra786/low-level-dev-skills core-dumps --agent claude-code

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

Manual copy
$ git clone --depth 1 https://github.com/mohitmishra786/low-level-dev-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/debuggers/core-dumps .claude/skills/core-dumps && rm -rf skills-src

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

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

Facts

Skill name
core-dumps
GitHub stars
253
Token cost
~1.3k tokens
SKILL.md length
209 words
Files
2 (incl. references)
Skills in repo
138
Repo updated
First seen
Licence
MIT

At a glance

Core dump analysis skill for production crash triage. An agent skill from mohitmishra786/low-level-dev-skills.

  • Works in 9 steps: Enable core dumps (Linux) → systemd/coredumpctl (modern Linux) → Enable core dumps (macOS) → …
  • Loading core files in GDB
  • SKILL.md covers Purpose, Triggers, Workflow and Related skills
  • Calls apt; reaches debuginfod.ubuntu.com and debuginfod.elfutils.org

What it does

Core Dumps is an agent skill from mohitmishra786/low-level-dev-skills. Core dump analysis skill for production crash triage. Use when loading core files in GDB or LLDB, enabling core dump generation on Linux/macOS, mapping symbols with debuginfo or debuginfod, or extracting backtraces from crashes without re-running the program. Activates on queries about core files, ulimit, coredumpctl, debuginfod, crash triage, or analyzing segfaults from production binaries.

Its SKILL.md is about 1.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/cheatsheet.md`).

It sits in Development. It works with Linux and macOS. The repository describes itself as: A curated suite of AI agent skills for systems and low-level programming with C/C++, Rust, and Zig toolchains, covering compilers, debuggers, profilers, build systems…. The licence is MIT.

When your agent uses it

  • Loading core files in GDB
  • Enabling core dump generation on Linux/macOS
  • Mapping symbols with debuginfo
  • Extracting backtraces from crashes without re-running the program

Example prompts

  • “/core-dumps”

Workflow steps

9 steps, taken from the step headings in SKILL.md.

  1. Enable core dumps (Linux)
  2. systemd/coredumpctl (modern Linux)
  3. Enable core dumps (macOS)
  4. Analyse a core with GDB
  5. Analyse a core with LLDB
  6. Missing symbols: debuginfod
  7. Missing symbols: manual approach
  8. Strip binaries and keep symbols
  9. Quick triage from core without full debug session

What it can do on your machine

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

  • Tool permissions

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

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • apt

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

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • debuginfod.ubuntu.com
    • debuginfod.elfutils.org

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

  • Credentials

    Names no API keys, tokens, secrets or passwords.

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

Context cost

Core Dumps loads about 1.3k tokens when it runs, and up to ~3.2k if it reads all its reference files. Until then it costs about 101 tokens; SKILL.md has 209 words of instructions outside code blocks.

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

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

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteRuns commands with sudoSKILL.md:37
    sudo sysctl -w kernel.core_pattern=/tmp/core-%e-%p-%t
  • NoteRuns commands with sudoSKILL.md:125
    sudo apt install debuginfod

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

SKILL.md

The full file from mohitmishra786/low-level-dev-skills at commit bdc5847, republished under its MIT licence (© mohitmishra786). 209 words, ~1,304 tokens.

Download SKILL.mdSave it as .claude/skills/core-dumps/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
core-dumps
description
Core dump analysis skill for production crash triage. Use when loading core files in GDB or LLDB, enabling core dump generation on Linux/macOS, mapping symbols with debuginfo or debuginfod, or extracting backtraces from crashes without re-running the program. Activates on queries about core files, ulimit, coredumpctl, debuginfod, crash triage, or analyzing segfaults from production binaries.

Core Dumps

Purpose

Guide agents through enabling, collecting, and analysing core dumps for post-mortem crash investigation without rerunning the buggy program.

Triggers

  • "My program crashed in production — how do I analyse the core?"
  • "How do I enable core dumps on Linux?"
  • "I have a core file but no symbols / source"
  • "How do I use debuginfod to get symbols for a core?"
  • "coredumpctl show me the crash"

Workflow

1. Enable core dumps (Linux)
bash
# Per-session (lost on logout)
ulimit -c unlimited

# Persistent (add to /etc/security/limits.conf)
*   soft   core   unlimited
*   hard   core   unlimited

# Check current limit
ulimit -c

# Set core pattern (where and how cores are named)
# Default: 'core' in CWD — often not useful
sudo sysctl -w kernel.core_pattern=/tmp/core-%e-%p-%t
# %e = executable, %p = PID, %t = timestamp

# Persistent (add to /etc/sysctl.d/99-core.conf)
kernel.core_pattern=/tmp/core-%e-%p-%t
kernel.core_uses_pid=1
2. systemd/coredumpctl (modern Linux)

If systemd manages core dumps (common on Ubuntu 20+, Fedora, Arch):

bash
# List recent crashes
coredumpctl list

# Show details of the latest crash
coredumpctl info

# Load latest crash in GDB
coredumpctl gdb

# Load specific PID crash
coredumpctl gdb 12345

# Export core file
coredumpctl dump -o myapp.core PID

Core storage location: /var/lib/systemd/coredump/.

3. Enable core dumps (macOS)
bash
# macOS uses /cores by default (must be root-writable)
ulimit -c unlimited

# Check
ls /cores/

# launchd-launched services: set in plist
# <key>HardResourceLimits</key>
# <dict><key>Core</key><integer>9223372036854775807</integer></dict>
4. Analyse a core with GDB
bash
# Load binary and core
gdb ./prog core.12345

# If the binary was stripped, provide the unstripped copy
gdb ./prog-with-symbols core.12345

# Essential first commands
(gdb) bt                    # call stack
(gdb) bt full               # stack + locals
(gdb) info registers        # CPU state at crash
(gdb) frame 2               # jump to interesting frame
(gdb) info locals           # local variables in frame
(gdb) print ptr             # inspect a pointer

# All threads (multi-threaded crash)
(gdb) thread apply all bt full
5. Analyse a core with LLDB
bash
lldb ./prog -c core.12345

# Or
lldb
(lldb) target create ./prog --core core.12345

# Commands
(lldb) bt
(lldb) thread backtrace all
(lldb) frame select 2
(lldb) frame variable
6. Missing symbols: debuginfod

debuginfod serves debug symbols from a central server, mapping build IDs to DWARF data.

bash
# Install client (Debian/Ubuntu)
sudo apt install debuginfod

# Enable (add to ~/.bashrc or /etc/environment)
export DEBUGINFOD_URLS="https://debuginfod.ubuntu.com https://debuginfod.elfutils.org"

# GDB auto-fetches symbols when DEBUGINFOD_URLS is set
gdb ./prog core

# Manually query
debuginfod-find debuginfo <build-id>
debuginfod-find source <build-id> /path/to/file.c
7. Missing symbols: manual approach
bash
# Check if binary has a build ID
readelf -n ./prog | grep Build

# Find the correct debug package
# Debian: apt install prog-dbg or prog-dbgsym
# RPM: dnf install prog-debuginfo

# Point GDB to debug symbols directory
(gdb) set debug-file-directory /usr/lib/debug

# Or use eu-readelf to dump build ID, then find .debug file
eu-readelf -n ./prog
find /usr/lib/debug -name "*.debug" | xargs eu-readelf -n 2>/dev/null | grep <build-id>
8. Strip binaries and keep symbols

Best practice: build with symbols, strip for distribution, keep an unstripped copy.

bash
# Build
gcc -g -O2 -o prog main.c

# Separate debug info
objcopy --only-keep-debug prog prog.debug
objcopy --strip-debug prog prog.stripped

# Add a debuglink so GDB finds the debug file automatically
objcopy --add-gnu-debuglink=prog.debug prog.stripped

# Deploy prog.stripped; keep prog.debug in a symbols store indexed by build-id
9. Quick triage from core without full debug session
bash
# Print backtrace non-interactively
gdb -batch -ex 'bt full' -ex 'thread apply all bt full' ./prog core 2>&1 | tee crash.txt

# Print registers
gdb -batch -ex 'info registers' ./prog core

# Check signal that caused crash
gdb -batch -ex 'info signal' ./prog core

For a full cheatsheet covering core pattern tokens, coredumpctl, GDB/LLDB commands, debuginfod servers, and strip/symbol workflows, see references/cheatsheet.md.

  • Use skills/debuggers/gdb for full GDB session details
  • Use skills/debuggers/lldb for LLDB-based analysis
  • Use skills/runtimes/sanitizers to catch the bug before it reaches production
  • Use skills/binaries/elf-inspection for readelf, build IDs, and binary inspection

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

Files

SKILL.md and 1 other file (references) in skills/debuggers/core-dumps of mohitmishra786/low-level-dev-skills.

  • SKILL.md
  • references/cheatsheet.md

Open the folder on GitHubat commit bdc5847

Compare with similar skills

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

Core Dumps compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Core Dumps this skillmohitmishra786/low-level-dev-skills253—~1.3kAutomated safety check: NotesMIT
Native Feel Cross Platform Desktopyetone/native-feel-skill1.9k1 repos~1.5kAutomated safety check: PassMIT
JS Cpp Protocolnotepadqq/notepadqq2.3k—~3.2kAutomated safety check: PassGPL-3.0
RStudio Copilot Language Server Updaterrstudio/rstudio5.1k—~1.1kAutomated safety check: PassCustom licence
OpenLogi Device DiagnosisAprilNEA/OpenLogi23k—~1.6kAutomated safety check: PassApache-2.0
Code Change Verificationopenai/openai-agents-python30k—~1.4kAutomated safety check: PassMIT

Similar skills

  • Native Feel Cross Platform Desktop

    yetone/native-feel-skill

    A skill your agent uses when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a…

    1.9k GitHub starsUsed in 1 repo~1.5k tokens
    DevelopmentAuto-check passed
  • JS Cpp Protocol

    notepadqq/notepadqq

    Reference for the communication protocol between the JavaScript editor (CodeMirror or Monaco) and the C++/Qt UI layer via QWebChannel.

    2.3k GitHub stars~3.2k tokensUpdated 4 days ago
    DevelopmentAuto-check passed
  • Advances RStudio's pinned copilot-language-server dependency to a specified release, then uploads it to S3, verifies the install, and opens a PR.

    5.1k GitHub stars~1.1k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • OpenLogi Device Diagnosis

    AprilNEA/OpenLogi

    Finds the first failing layer when an OpenLogi Logitech device is missing or misbehaving across enumeration, open, probe, IPC and UI.

    23k GitHub stars~1.6k tokensUpdated today
    DevelopmentAuto-check passed
  • Code Change Verification

    openai/openai-agents-python

    Official

    Run the required final formatting, lint, type, and test checks after eligible SDK changes pass review.

    30k GitHub stars~1.4k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Tk Impact Analysis

    tonkeeper/tonkeeper-web

    Analyze QA regression impact for Tonkeeper Web by comparing the current branch with the relevant release tag, reviewing sources/Web/regress.txt, and recommending test blocks, missing coverage, extra…

    444 GitHub stars~3.7k tokensUpdated 7 days ago
    DevelopmentAuto-check passed

More from mohitmishra786/low-level-dev-skills

All 138 skills in this repo
  • ARM and AArch64 Assembly

    mohitmishra786/low-level-dev-skills

    Guides reading and writing AArch64 and ARM Thumb assembly: compiler output, inline asm, registers, the AAPCS calling convention and NEON or SVE basics.

    253 GitHub stars~1.9k tokensUpdated 3 mo ago
    Auto-check passed
  • RISC-V Assembly Guide

    mohitmishra786/low-level-dev-skills

    Reference for RISC-V assembly on RV32 and RV64: register names and calling convention, extension naming, GCC and Clang inline asm, and QEMU with GDB debugging.

    253 GitHub stars~1.8k tokensUpdated 3 mo ago
    Auto-check passed
  • x86-64 Assembly Reference

    mohitmishra786/low-level-dev-skills

    Explains x86-64 registers, the System V AMD64 calling convention, and how to read compiler-generated or inline assembly.

    253 GitHub stars~1.5k tokensUpdated 3 mo ago
    Auto-check passed
  • Bazel for C and C++

    mohitmishra786/low-level-dev-skills

    Guides your agent through Bazel for C/C++ projects: BUILD files, Bzlmod dependencies, toolchain registration, remote execution, dependency queries and sandbox debugging.

    253 GitHub stars~1.5k tokensUpdated 3 mo ago
    Auto-check passed
  • Binary Hardening

    mohitmishra786/low-level-dev-skills

    Binary hardening skill for security-hardened C/C++ builds. An agent skill from mohitmishra786/low-level-dev-skills.

    253 GitHub stars~2k tokensUpdated 3 mo ago
    Auto-check passed
  • Binutils

    mohitmishra786/low-level-dev-skills

    GNU binutils skill for binary manipulation and analysis. An agent skill from mohitmishra786/low-level-dev-skills.

    253 GitHub stars~1.2k tokensUpdated 3 mo ago
    Auto-check passed

Works with

Categories

Questions about Core Dumps

What does Core Dumps do?

Core dump analysis skill for production crash triage. An agent skill from mohitmishra786/low-level-dev-skills. Core Dumps is an agent skill from mohitmishra786/low-level-dev-skills. Core dump analysis skill for production crash triage.

When should I use Core Dumps?

Core Dumps fits situations like: loading core files in GDB; enabling core dump generation on Linux/macOS; mapping symbols with debuginfo; extracting backtraces from crashes without re-running the program.

How do I install Core Dumps in Claude Code?

Run `npx skills add mohitmishra786/low-level-dev-skills --skill core-dumps -a claude-code`. Or copy the skill folder (skills/debuggers/core-dumps in mohitmishra786/low-level-dev-skills) into .claude/skills/core-dumps in your project. Claude Code loads it when a task matches its description.

How do I install Core Dumps in Codex?

Run `npx skills add mohitmishra786/low-level-dev-skills --skill core-dumps -a codex`. Or copy the skill folder (skills/debuggers/core-dumps in mohitmishra786/low-level-dev-skills) into .agents/skills/core-dumps in your project. Codex loads it when a task matches its description.

Can I use Core Dumps in Cursor, Gemini CLI or GitHub Copilot?

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

What does Core Dumps need to run?

Going by SKILL.md and its folder, Core Dumps needs the command-line tools its instructions call (apt).

Does Core Dumps access the network?

SKILL.md names 2 domains. In commands or code: debuginfod.ubuntu.com and debuginfod.elfutils.org; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Core Dumps safe to install?

Our automated static check of SKILL.md found notes only (runs commands with sudo), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Core Dumps use?

Core Dumps is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Core Dumps use?

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

What are the alternatives to Core Dumps?

Skills that share tags, products or a category with Core Dumps: Native Feel Cross Platform Desktop (yetone/native-feel-skill, 1.9k stars), JS Cpp Protocol (notepadqq/notepadqq, 2.3k stars), RStudio Copilot Language Server Updater (rstudio/rstudio, 5.1k stars) and OpenLogi Device Diagnosis (AprilNEA/OpenLogi, 23k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Core Dumps?

mohitmishra786 (a GitHub user) maintains it in mohitmishra786/low-level-dev-skills, which has 253 GitHub stars. The repository holds 138 skills in this directory. The repository was last updated on June 27, 2026.

Source: mohitmishra786/low-level-dev-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.