Results for “software”

Generate flat, minimal light/dark-aware SVG diagrams as standalone HTML files, using a unified educational visual language with 9 semantic color ramps, sentence-case typography, and automatic dark mode. Best suited for educational and non-software visuals — physics setups, chemistry mechanisms, math curves, physical objects (aircraft, turbines, smartphones, mechanical watches), anatomy, floor plans, cross-sections, narrative journeys (lifecycle of X, process of Y), hub-spoke system integrations (smart city, IoT), and exploded layer views. If a more specialized skill exists for the subject (dedicated software/cloud architecture, hand-drawn sketches, animated explainers, etc.), prefer that — otherwise this skill can also serve as a general-purpose SVG diagram fallback with a clean educational look. Ships with 15 example diagrams.

The English summary is being prepared. Showing the original description.

Expert reverse engineer specializing in binary analysis, disassembly, decompilation, and software analysis. Masters IDA Pro, Ghidra, radare2, x64dbg, and modern RE toolchains. Handles executable analysis, library inspection, protocol extraction, and vulnerability research. Use PROACTIVELY for binary analysis, CTF challenges, security research, or understanding undocumented software.

The English summary is being prepared. Showing the original description.

Parses Software Bill of Materials (SBOM) in CycloneDX and SPDX JSON formats to identify supply chain vulnerabilities by correlating components against the NVD CVE database via the NVD 2.0 API. Builds dependency graphs, calculates risk scores, identifies transitive vulnerability paths, and generates compliance reports. Activates for requests involving SBOM analysis, software composition analysis, supply chain security assessment, dependency vulnerability scanning, CycloneDX/SPDX parsing, or CVE correlation.

The English summary is being prepared. Showing the original description.

Comprehensive offensive methodology for software supply chain attacks covering the full kill chain from reconnaissance through exploitation. Addresses dependency confusion across npm, PyPI, and NuGet ecosystems where internal registry override allows an attacker to inject malicious packages that shadow private dependencies. Covers typosquatting techniques for popular packages, compromised package injection via maintainer account takeover or social engineering, and build system attacks through Makefile injection, setup.py install hooks, and npm postinstall scripts. Extends into CI/CD artifact tampering where build outputs are replaced or modified in transit, code signing abuse through stolen or self-signed certificates, upstream repository compromise via commit injection or force-push to trusted repos, and container image supply chain attacks including base image trojaning and registry confusion. Maps to MITRE ATT&CK T1195.001 (Supply Chain Compromise: Compromise Software Dependencies and Development Tools...

The English summary is being prepared. Showing the original description.

Review new and existing software tests for the behavior and regressions they actually protect. Identify duplicate or implementation-dependent checks, document evidence before removal, and simplify code used only by tests while retaining meaningful coverage.

• Checking whether a new test adds useful coverage
• Auditing duplicate or implementation-dependent tests
• Reviewing code exposed only for testing

Clarifies the purpose, preferences, and constraints of a new feature or project through conversation. When useful, it offers mockups or temporary prototypes, then captures an agreed description or written design before implementation begins.

• Clarifying the purpose of a new feature
• Organizing ideas for a talk or business
• Comparing screen or room layouts visually

Choose which related skill to use and in what order for planning, building, debugging, or maintaining software. It explains routes through the available workflows and helps select the next step based on your situation and project size.

• Choosing a workflow from idea to implementation
• Finding the right starting point for bug investigation
• Planning a build that spans multiple sessions

Connect software to X (Twitter) to publish posts and threads, upload images, read timelines, search conversations, and track engagement. Covers authentication, access checks, and handling limits on how often the API can be called.

• Publishing posts, threads, and image posts through the API
• Retrieving timelines and user information
• Searching posts about a topic or conversation

Add machine learning to an existing application through a structured workflow. The skill guides problem definition, data checks, separation from business logic, and training and evaluation of a simple initial model.

• Adding recommendations to an existing application
• Checking whether training data is ready
• Integrating a prediction model with fallback rules

Review US healthcare software for HIPAA privacy and security concerns. The skill guides checks on protected health information, vendor agreements, minimum necessary access, and audit records, while directing implementation and specialized review to related skills.

• Reviewing AI-generated visit summaries for HIPAA concerns
• Checking patient data flows into analytics services
• Planning minimum necessary access and audit records

Record software design decisions as numbered Markdown files, with context, rejected alternatives, benefits, drawbacks, and risks. Maintain an index and consult existing ADRs—architecture decision records—to explain why a framework, database, or design approach was chosen.

• Record reasons for framework or database choices
• Document design alternatives and trade-offs
• Find explanations for past technical decisions

Investigate suspected malicious changes in open-source software on GitHub by comparing repository history, APIs, and archives. Attempt to recover deleted evidence, identify signs of compromise, and produce a report separating verified facts from hypotheses.

• Investigate suspicious commits or workflow changes
• Attempt to recover commits hidden by rewritten history
• Trace possible credential leaks

Investigate software errors by tracing code, reviewing recent changes, and reproducing symptoms. Test a specific cause before making a minimal fix, then verify the result with regression tests and a structured debug report.

• Investigating errors and stack traces
• Tracing bugs introduced by recent changes
• Verifying fixes and documenting regression tests

Investigate software errors and unexpected behavior through four stages: investigation, analysis, hypothesis, and implementation. It requires identifying the root cause before making fixes and distinguishes evidence from code inspection, tests, and live runs when reporting findings.

• Investigate server errors
• Trace an error using a stack trace
• Find why previously working behavior stopped

Find guidance on Codex settings, pricing, and OpenAI products and APIs using current official documentation. Get cited answers for setup, troubleshooting, model comparisons, migration planning, and prompt changes, with uncertainty stated when sources are inconclusive.

• Check Codex settings and troubleshoot problems
• Compare models for cost, speed, and quality
• Plan a model migration and adjust prompts

Document why software decisions were made, which alternatives were considered, and what trade-offs remain. Create architecture decision records, README guidance, API documentation, and changelogs that help future contributors and AI agents understand the project.

• Recording design decisions and rejected alternatives
• Documenting public API changes
• Updating README setup instructions

Refine interface components using Emil Kowalski's design engineering principles. Decide when animation helps, tune timing and interaction feedback, and review CSS choices with attention to performance, accessibility, and details such as tooltips and drag behavior.

• Deciding whether an interaction needs animation
• Refining buttons, tooltips, and notifications
• Reviewing UI code with before-and-after comparisons

Improve an AI agent's harness, the software that organizes its work, while keeping the model fixed. Test changes in a sandbox, measure their results, and retain variants that pass tests and demonstrate improvement.

• Tune an agent harness without changing its model
• Compare changes to planning, context, or retry policies
• Try an offline dry run without executing tests

Organize software releases on GitHub, from version suggestions and release notes to testing, builds, and deployment. Coordinate multiple packages or repositories, roll changes out in stages, and configure rollback to restore an earlier release when problems occur.

• Preparing version updates and release notes
• Coordinating releases across packages and repositories
• Deploying in stages with monitoring and rollback

Organize software development from requirements and architecture through testing, review, and deployment. Use specialized agent roles, shared memory, and test-driven development, where tests are written before code, to coordinate work across the project.

• Plan and implement a new feature
• Refactor legacy code with supporting tests
• Review code security and performance

Find official documentation for a library, framework, or API and apply it to the task at hand. Check the relevant version, distinguish documented facts from assumptions, and verify code changes with a focused test or concrete command.

• Checking how an API or option works
• Implementing behavior for a specific version
• Applying official guidance to an existing project

Build features or fix bugs by writing a small test first, checking that it fails for the expected reason, and making the smallest code change needed. Run related tests and review the changes for unintended effects.

• Reproducing a bug with a regression test
• Defining expected behavior before implementing a feature
• Checking parser, routing, or UI behavior changes

Turn source code into project documentation, from a README with installation steps and examples to API references, architecture diagrams, developer guides, and changelogs. Match the scope and comment format to the project's size and programming language.

• Creating a README with installation steps and usage examples
• Documenting public functions, parameters, and return values
• Preparing architecture and contributor guides for new developers

Turn software development goals into manageable milestones with clear deliverables, dependencies, effort estimates, and success criteria. Use it to plan feature implementation, bug fixes, refactoring, performance improvements, and testing work.

• Planning OAuth2 authentication implementation
• Setting measurable database performance targets
• Breaking refactoring into incremental steps