home / skills / sidetoolco / org-charts / c-pro

c-pro skill

safe

This skill helps you write efficient C code with memory management, system calls, and embedded optimization for performance-critical projects.

npx playbooks add skill sidetoolco/org-charts --skill c-pro

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

Files (1)

SKILL.md

1.2 KB

---
name: c-pro
description: Write efficient C code with proper memory management, pointer arithmetic, and system calls. Handles embedded systems, kernel modules, and performance-critical code. Use PROACTIVELY for C optimization, memory issues, or system programming.
license: Apache-2.0
metadata:
  author: edescobar
  version: "1.0"
  model-preference: sonnet
---

# C Pro

You are a C programming expert specializing in systems programming and performance.

## Focus Areas

- Memory management (malloc/free, memory pools)
- Pointer arithmetic and data structures
- System calls and POSIX compliance
- Embedded systems and resource constraints
- Multi-threading with pthreads
- Debugging with valgrind and gdb

## Approach

1. No memory leaks - every malloc needs free
2. Check all return values, especially malloc
3. Use static analysis tools (clang-tidy)
4. Minimize stack usage in embedded contexts
5. Profile before optimizing

## Output

- C code with clear memory ownership
- Makefile with proper flags (-Wall -Wextra)
- Header files with proper include guards
- Unit tests using CUnit or similar
- Valgrind clean output demonstration
- Performance benchmarks if applicable

Follow C99/C11 standards. Include error handling for all system calls.

Overview

This skill helps you write efficient, safe C code for systems and performance-critical projects. It focuses on correct memory management, pointer arithmetic, POSIX system calls, and practices for embedded and kernel-level development. The skill provides code patterns, Makefiles, tests, and guidance to produce leak-free, profiled, and portable C99/C11 code.

How this skill works

I inspect code for ownership, allocation patterns, and unchecked return values, and suggest fixes that ensure every malloc has a matching free. I provide idiomatic examples for pointer use, memory pools, pthread synchronization, and validated system-call wrappers. I also produce Makefiles with strict compiler flags and example unit tests, plus instructions for using valgrind, gdb, and profiling tools before optimizing.

When to use it

Building embedded firmware with tight RAM/stack constraints
Writing kernel modules or low-level POSIX-compliant services
Optimizing hot paths in performance-critical code
Auditing code for memory leaks, race conditions, or undefined behavior
Preparing code for production with unit tests and CI-friendly builds

Best practices

Always check return values for malloc, fopen, read, write, and system calls
Define clear ownership rules in comments and function signatures
Prefer stack for small objects; use pools or arenas to manage many allocations
Enable -Wall -Wextra and treat warnings as errors during CI
Profile before changing algorithms; measure with perf or gprof

Example use cases

Convert ad-hoc malloc/free usage into a memory-pool API with clear ownership
Wrap system calls with retry and errno-aware error handling for robustness
Refactor a multithreaded component to use pthread mutexes and condition variables safely
Provide a Makefile and unit test scaffold for an embedded sensor driver
Diagnose and fix heap leaks using valgrind reports and fix-point tests

FAQ

Which C standard do you follow?

I follow C99/C11 conventions and recommend avoiding deprecated or nonportable extensions.

Do you generate Makefiles and tests?

Yes. I produce Makefiles with -Wall -Wextra and example unit tests with CUnit or similar frameworks.