betaFeedback

WorksComputer Science

How Agent Skills Evolve: A Large-Scale Empirical Study of Skills on GitHub

Abstract

Large language model-based agents increasingly rely on external skills to reuse task-specific knowledge without retraining the model. As skills become common for extending agent capabilities, understanding creation and evolution is critical for reliable agent systems. However, existing studies mainly examine agent skills from a static perspective, leaving their evolution in real-world repositories largely unexplored. This limits our understanding of the patterns and motivations behind skill changes. To fill this gap, we present a large-scale empirical study of agent skills, capturing 84,200 skills and 750,898 commits from GitHub. We manually construct taxonomies of skill components, change patterns, and evolution motivations, and build an automated annotation pipeline to label changes at scale. Based on the taxonomy, we conduct quantitative analyses of skill composition and post-creation evolution frequency, together with qualitative assessments of modified components, change patterns, and motivations. Our findings reveal five implications: (i) reliability receives less attention in skill composition and change, motivating execution-contract skill design that incorporates verification and recovery mechanisms; (ii) evolution changes concentrate in project-coupled skills, calling for automated just-in-time skill updating mechanisms; (iii) change patterns are dominated by incremental enrichment and refinement, motivating pattern-guided skill enhancers that diagnose and improve incomplete skill components; (iv) redundancy is a practical maintenance issue, highlighting the need for context-efficient skill representation; (v) security-motivated changes show limited risk reduction, suggesting skill regression testing methods that objectively verify skill functionality and security. Beyond these insights, our dataset provides a basis for future studies on automated skill techniques.

Introduction

Recent artificial intelligence (AI) systems have been shifting from single-turn, passive, reactive large language models (LLMs) to autonomous AI agents [1, 2, 3, 4]. Unlike traditional LLM systems that primarily generate responses to user inputs [5, 6, 7], AI agents are designed to accomplish task objectives autonomously: they can perform multi-step reasoning and planning, invoke external tools on demand, interact with working environments, and maintain task context through memory mechanisms [8, 9, 10, 11]. Among these capabilities, agent skills are introduced as an important mechanism for packaging reusable task knowledge and execution procedures. A skill is a structured, reusable functional unit that can be loaded into the agent context as needed [12]. As illustrated in Figure 1, a skill is typically organized around a main instruction file (e.g., SKILL.md), which contains metadata for retrieval, workflow instructions, and task-specific knowledge, and may be accompanied by executable scripts and associated resources. By retrieving and composing skills during execution, agents can acquire domain-specific capabilities without retraining the underlying model, making skills an important building block for extending agent functionality [13, 14].

Figure 1. File Structure of an Agent Skill

With models, tools, memory, and external knowledge (skills) orchestrated around agents, agent-based systems are evolving from prompt-response interfaces into a new form of software systems. In this form, foundation models serve as decision-making cores, tools provide external actions, memories preserve task context and experience, and skills encapsulate reusable execution knowledge. From a software engineering perspective, agent skills can be viewed as a new class of software artifacts. Skills are created, revised, reused, and maintained. They need to be continuously updated to changing task requirements, tool interfaces, execution environments, and user feedback. Studying these updates helps understand how skills evolve in practice and provides empirical guidance for writing, validating, and improving skills in the future.

The rapid evolution of the ecosystem surrounding agent skills has attracted increasing research attention [15, 16]. Empirical studies have been conducted to examine the acquisition, retrieval, and security risks of skills [17, 18, 19]. While these studies provide a static view of skills, the longitudinal evolution of real-world skill artifacts is under-explored, i.e., how they change across time is still unknown. This gap limits our understanding of the underlying patterns and latent motivations behind changes in skills. To bridge the gap, we construct a large-scale dataset of 84,200 agent skills and 750,898 related commits from real-world GitHub repositories and conduct an empirical study of skill evolution. By studying skills as evolving software artifacts, we aim to learn how frequently they evolve, which parts are modified, what kinds of changes developers make, and what motivations drive these changes.

We study the following research questions and sub-questions.

  • RQ1: What is the current status of agent skills in open-source repositories? We provide an overview of existing skills, focusing on their composition and evolution frequency.

  • RQ1.1: What are the main components of agent skills? We manually construct a component taxonomy from inspected samples. Based on this taxonomy, we classify skill content into fine-grained functional components and quantify their occurrence in real-world repositories. The results show that most skills are currently used primarily to structure prompts, procedural guidance, and domain knowledge. At the fine-grained level, we observe that skills provide limited explicit quality assurance and failure-handling mechanisms.

  • RQ1.2: How frequently do agent skills evolve over time? We identify content-related modification commits as evolution events and analyze their counts and temporal intervals. Our findings show that most skills experience limited maintenance, and frequent evolution is concentrated in a small subset of complex and project-coupled skills. This concentration suggests that project-coupled skills incur high manual maintenance costs as their dependent projects evolve, highlighting the need for automated mechanisms that can efficiently propagate project-level changes into corresponding skill updates.

  • RQ2: Which components of agent skills are modified during evolution? Based on the collected dataset, we retrieve historical skill versions, parse file-level diffs, and use LLM-assisted component labeling to map changed content to functional components. We find that skill evolution is concentrated in instruction-oriented components. Within the instruction-oriented components, reliability-oriented components often receive less attention from developers. Given the inherent ambiguity of skills as natural language artifacts and the stochastic nature of LLM-based execution, the outcomes can be highly unpredictable. Reliability is therefore a non-negligible concern for developers.

  • RQ3: What types of changes characterize agent skill evolution? To organize skill changes and their motivations under a unified framework, we sample evolution commits and manually construct a taxonomy of change patterns and latent motivations. Guided by the taxonomy, we aggregate file-level diffs into changed-component units, use LLM-assisted labeling to assign each unit a how label, and quantify the resulting distribution of change patterns. The results indicate that change patterns is dominated by incremental enrichment and refinement, while structural reorganization is rare. This suggests that future automated skill maintenance tools may prioritize iterative enrichment- and refinement-oriented support over structural-level revisions. Redundancy is also a practical maintenance issue in skill evolution, with developers frequently simplifying skill content by removing unnecessary artifacts and duplicated instructions. This is especially beneficial for token saving in long-horizon agent task execution, where repeated skill invocations can otherwise lead to substantial context accumulation.

  • RQ4: What motivates the evolution of agent skills? Using the motivation dimension of the taxonomy constructed in RQ3, we also annotate each changed-component unit with a label and analyze the distribution of motivations. This analysis shows that skill evolution is dominated by Perfective maintenance, especially improving functionality and retrievability. In contrast, reliability- and risk-oriented maintenance receive limited attention. As AI agents frequently involve substantial risky operations, such as file modification and network access, ensuring the reliability and risk-prevention of skills that govern these operations should be treated as a maintenance priority. For security-related changes, we further compare the scanner-reported risks before and after the corresponding commits, and find that only a small fraction of changes are accompanied by observable reductions in risks. This gap between intended and observed risk reduction highlights the need for executable tests that can objectively verify skill functionality and security.

To the best of our knowledge, we are the first large-scale empirical study of agent skill evolution, providing a comprehensive understanding of the current status, evolution patterns, and motivations behind skill changes. In summary, this paper makes the following contributions:

  • Dataset. We construct and release a large-scale dataset capturing the evolution history of agent skills, comprising 84,200 skills and 750,898 commits from real-world GitHub repositories. This dataset provides a foundation for a wide range of empirical analysis.

  • In-depth Study. We conduct a comprehensive empirical study of agent skill evolution, uncovering characteristics, key patterns, and motivations behind skill changes.

  • Implications. Based on our findings in skill evolution, we discuss research opportunities in the skill ecosystem, focusing on automated skill refinement, skill testing, and context-efficient skill representation.

Agent skills: modular and reusable capabilities

An agent skill is a predefined, reusable, task-oriented capability module that helps agents solve specific tasks. Unlike knowledge encoded in model parameters, skills are external artifacts that explicitly describe task-specific workflows, tool usage patterns, constraints, and domain expertise. This design allows agents to acquire new capabilities without retraining, reuse prior task experience across similar scenarios, and improve the consistency and reliability of task execution [20, 21, 22]. Structurally, a skill is typically organized as a standalone directory. As shown in Figure 1, it usually contains a core guidance file, such as SKILL.md, which includes retrieval metadata and execution workflow, and may include executable scripts or associated resources such as reference documents and configuration files.

Recent studies divide the lifecycle of agent skills into three stages: acquisition, retrieval/selection, and evolution [23]. A typical lifecycle starts with skill acquisition, where reusable procedural artifacts are created from human expertise or execution traces. These skills are then indexed and retrieved from skill libraries, selected according to the current task context. Based on execution feedback, existing skills can be modified and evolved over time. Following this lifecycle view, existing techniques can be grouped into skill acquisition, skill retrieval and selection, and skill evolution. Prior work addresses skill acquisition from interaction experience or external documents [24, 25, 26], skill retrieval and selection based on task context and constraints [27, 28, 29], and skill evolution through failure-driven revision [30, 31, 32]. Rather than proposing a specific technique, our work empirically studies real-world skill evolution from multiple perspectives.

Empirical Studies on Agent Skills

As agent skills have rapidly emerged in agent ecosystems, recent studies have begun to empirically characterize their content, structure, and security [18], [19], [33]. Ling et al. [18] conduct a large-scale data-driven analysis of publicly listed Claude skills, examining their categories, adoption patterns, length distribution, and redundancy. Liu et al. [19] further study the security risks of agent skills at scale. They identify vulnerability patterns such as prompt injection, data exfiltration, privilege escalation, and supply-chain risks. Complementary to vulnerability analysis, another recent study [33] constructs a behaviorally verified dataset of malicious skills and reveals how malicious instructions, hidden behaviors, and attack payloads appear in real-world skill ecosystems.

However, they mainly treat skills as static artifacts and focus on characteristics of content, while the longitudinal evolution of real-world skills is under-explored. Our work complements them by reconstructing skill evolution histories from commits and analyzing modified components, evolution patterns, and underlying motivations behind these changes.

Methodology

In this section, we present the methodology of our study. Our pipeline is described in Figure 2, from dataset collection to the analysis of collected data.

Figure 2. Overview of Methodology

Dataset Construction

To investigate how agent skills evolve in real-world settings, a dataset that contains skills with evolutionary histories is needed. This section describes our dataset construction pipeline, including repository collection, candidate skill collection, and evolution history filtering.

Repository Collection. GitHub hosts over 300 million repositories. The first challenge lies in identifying high-quality repositories that may contain skill files. As the concept of agent skills was formally introduced by Anthropic in October 2025 [12], we conservatively set September 1, 2025, as the starting date of our collection window, which extends through April 23, 2026. We leverage the GH Archive dataset [34] to identify active and potentially relevant repositories. Specifically, we retain repositories with more than three stars and more than three push events during the target period. We use these low thresholds as a conservative lower bound, ensure a minimal level of public visibility and recent development activity while retaining newly created repositories that may contain agent skills. This stage provides the initial pool of 196,970 repositories for subsequent skill file mining.

Candidate Skill Collection. Based on the collected repositories, we identify files that potentially correspond to agent skills. Since skill files may follow different naming conventions and directory layouts across projects, we adopt a pattern-based search strategy. Specifically, we consider files matching common skill-related patterns, including skill.md, files under .codex/skills and .claude/skills, and Markdown files located in directories named skills. Following existing skill file specifications [35], we further apply heuristic rules to remove clearly invalid candidates. Specifically, we retain a skill file only when it provides the required metadata, including non-empty name and description fields, and contains sufficient content, i.e., more than 100 bytes. This stage yields 296,051 candidate skill files.

Evolution History Filtering. Finally, we filter the evolution histories of the collected candidate skills. To ensure that each skill has an analyzable evolutionary history, we require each retained skill file to have more than three commits. Here we define non-substantive commits as commits that are explicitly intended to fix minor textual errors. Concretely, we identify potentially non-substantive commits based on commit messages containing keywords such as typo, spelling, and grammar. Then we validate whether the remaining commits contain content changes by checking their file-level patches, retaining only commits with non-whitespace added or removed lines. After deduplication, we obtain a dataset composed of 84,200 skills across 7,776 repositories, along with 750,898 related commits.

Analysis of Current Skill Status

To address RQ1, we conduct a statistical analysis based on the dataset from two perspectives: structural composition and evolution frequency.

Detailed Component Category. As discussed in II-A, the existing open format for agent skills mainly categorizes skill content by file type [35]. However, file-level categorization cannot capture the evolution of fine-grained functional contents within a skill. Therefore, we further classify skill content from a functional perspective to support fine-grained evolution analysis.

To determine these categories, 383 skill files are independently and manually labeled by two authors of the study. Following prior work [36], [37], the sample size ensures a 95% confidence level with a ±5% margin of error. After the independent data annotation process, a collaborative review was undertaken by the two authors to reconcile disagreements and finalize the categories through consensus, thereby solidifying the taxonomy used in our subsequent analysis. Finally, we established five top-level categories: metadata, workflow, knowledge, resources, and others, which are shown in Table I.

Evolution Frequency Overview. To characterize the overall activeness of skill evolution, we reconstruct each skill’s post-creation evolution history from repository commits. We define a commit that modifies a specific skill as a skill evolution event, and exclude each skill’s initial creation commit, as our focus is on post-creation evolution rather than skill introduction. Based on these events, we measure: (1) the number and proportion of skills with at least one evolution event, (2) the number of evolution events per skill, and (3) the time intervals between consecutive evolution events. These metrics capture the prevalence, frequency, and temporal rhythm of skill evolution.

Identification of Modified Skill Components

To address RQ2, we further investigate where changes occur within skill content. Specifically, we take each skill evolution event as the unit of analysis and map the modified contents in each event to the predefined skill components based on the previously constructed component taxonomy. To illustrate this process, we provide an example in our online appendix2.

Step 1: Version-level Block Construction. A skill directory typically contains a main instruction file (i.e., SKILL.md) and several auxiliary resource files, such as scripts, data files, and supplementary documents. Since these two types of files play different roles in a skill, we process them separately.

For the main instruction file, we retrieve both its pre-change and post-change versions for each evolution event. We parse each version into blocks based on Markdown format, including frontmatter, paragraphs, lists, tables, and code fences. Each block preserves its line range, block type, heading path, and textual content. This version-level block representation allows us to assign semantic components to the skill content in a more structured manner. For auxiliary resource files, we do not parse their internal content because these files are heterogeneous in format and lack a unified structure. Instead, we extract their file-level diffs from the commit patch as evidence for analyzing their concrete modifications.

Step 2: Component Labeling and Change Localization. After constructing Markdown blocks for both versions of SKILL.md, we map these blocks to our predefined skill component taxonomy. Specifically, we provide the full content as context and ask an LLM to assign each target block to exactly one skill component. The main instruction file is classified into components, including metadata, workflow, and knowledge. Auxiliary resource files are also categorized by file type, including knowledge and resources. For labeling, we use DeepSeek-V4-Flash [38], as it provides strong semantic understanding at a reasonable cost for large-scale labeling. We evaluate the reliability of automated annotation in § 5-A, where the component-labeling task achieves an accuracy score of 0.881 against manually labeled data.

We then perform line-level analysis for the commit diff between the pre-change and post-change versions. For modifications, the removed side is mapped to blocks in the pre-change version, and the added side is mapped to blocks in the post-change version. Pure deletions and insertions are mapped to the pre-change and post-change versions, respectively. Each changed line is mapped to its corresponding labeled Markdown block, thereby identifying the affected skill component. For auxiliary resource files, we map the file-level change to the component label assigned to the corresponding file. The detailed prompt for labeling is provided in our online appendix2.

Step 3: Aggregation. Finally, we aggregate the labeled changes at the granularity of a skill evolution event. If multiple changed Markdown blocks or auxiliary files in the same evolution event are mapped to the same component, we merge them into one changed component. As a result, each evolution event is represented as a set of changed skill components. Based on this representation, we compute the frequency and proportion of modifications for each skill component. This enables us to identify which parts of agent skills are more likely to evolve and provides the basis for further analyzing their evolution patterns and motivations.

Taxonomy of Evolution Patterns and Motivations

To address RQ3 and RQ4, we construct a two-dimensional taxonomy of skill evolution on top of the previously annotated skill components. Specifically, the “how” dimension captures the change operation applied to a modified component, while the “why” dimension captures the evolution motivation behind the modification.

ComponentSubcomponentDefinition
MetadataIdentityBasic information that identifies a skill, such as name, version, author, or category.
FunctionalityDescriptions of the skill’s capability.
Trigger conditionConditions that determine when the skill should be retrieved or invoked.
WorkflowExecutionStep-by-step procedures and operational logic to obtain results
VerificationSteps for validating intermediate or final results during the workflow.
RecoveryError-handling or fallback strategies for failed executions.
Format specificationSpecifications of inputs, outputs, and intermediate results
KnowledgeInternal guidanceBackground knowledge or domain-specific guidance embedded in Skill.md.
Complementary documentsExternal reference documents that supplement the main skill file.
ResourcesCode scriptsExecutable scripts or program files used during task execution.
Data filesAuxiliary data files, such as configurations, credentials, or dependencies.
OthersMiscellaneousOther files that do not fall into the above categories, like evaluation files.

Table 1. Taxonomy of skill components.

Taxonomy Construction. We randomly sampled 384 commits to annotate, following the same independent annotation and consensus review procedure in III-B. This sample size also satisfies the minimum requirement for a 95% confidence level with a ±5%\pm5\% margin of error. To further assess the stability of the taxonomy, we additionally inspected 20 randomly selected commits after the initial taxonomy was constructed. In total, our manual inspection covered 404 commits across 27 skills. The additional inspection did not lead to any changes to the taxonomy, indicating that the schema was stable for our dataset.

For each sampled evolution commit, we first inspect the pre-change and post-change skill contents together with file-level diffs to identify the modified components. After the modified components are determined, annotators use each changed component as the annotation unit and assign one how label and one why label based on the commit message, localized diff, and surrounding skill context.

Based on these manually inspected samples, we first annotate the modified components in each skill evolution event following the same procedure described in III-B. After obtaining the component labels, we map the changed lines in each commit to their corresponding components. Then, for each component, we categorize the corresponding change operations and infer the maintenance intents based on the commit messages, changed lines, and skill content. We report the annotation reliability for both modified component identification and evolution pattern/motivation labeling in § 5-A. The accuracy scores for component, change-pattern, and motivation labels are 0.913, 0.816, and 0.840, indicating that the automated annotations are highly consistent with human labels. During taxonomy construction, we drew on the classical software maintenance taxonomy [39], [40] and adapted it to the agent skill.

Taxonomy Structure. Figure 3 presents the hierarchical structure of our taxonomy for skill evolution. The taxonomy is organized into four top-level maintenance intents: Corrective, Adaptive, Perfective, and Preventive Maintenance. Each motivation is further decomposed into fine-grained why categories, shown as colored nodes, which are associated with concrete how operations, shown as white nodes. In this way, the taxonomy connects the reason for a skill change with the specific operation through which the change is implemented.

Taxonomy of skill evolution motivations and patterns

Figure 3. Taxonomy of skill evolution motivations and patterns. Colored nodes denote fine-grained “why” categories, while white nodes denote concrete “how”.

Corrective Maintenance refers to changes that resolve deviations between a skill’s current behavior and its intended design goal. Such changes address missing, incorrect, or unstable skill content, including incomplete functionality, erroneous workflow steps, inaccurate knowledge descriptions, and underspecified execution conditions.

Adaptive Maintenance captures changes motivated by external shifts rather than defects in the skill itself. These changes are needed when the surrounding toolchain, execution environment, interface, data format, or target task evolves, requiring the skill to be realigned with its updated usage context.

Perfective Maintenance describes changes that improve a skill that is already functional. These changes go beyond basic correctness by enhancing skill capability, efficiency, and usability, reflecting developers’ efforts to make skills more effective in supporting future task execution.

Preventive Maintenance denotes changes that proactively reduce future risks or maintenance costs. Although the current skill may remain executable, it may expose potential security, robustness, traceability, artifact-management, or evaluation risks. Preventive changes aim to mitigate such risks before they lead to failures.

A detailed explanation of the fine-grained categories is provided in our online appendix2.

Automatic Annotation. Based on this taxonomy, we implement an automatic annotation pipeline. Consistent with Section III-C, we also use DeepSeek-V4-Flash as the annotation model. To avoid the coarse granularity of commit-level annotation and the excessive fragmentation of line-level annotation, we use the changed component defined in III-C as the basic annotation unit. Specifically, each changed component is represented as the tuple ⟨commit,file scope,component⟩\langle\text{commit},\text{file scope},\text{component}\rangle. For changed components in SKILL.md, we provide the model with commit metadata, the target component, and block-level diffs with the full file as context. The block-level diffs include component type, heading path, and localized diffs. For changed components in auxiliary files, we extract the corresponding per-file diff from the original commit patch and provide it together with the file path and component label.

Based on the taxonomy and the above artifacts, the model is required to produce a strictly structured JSON output containing one how label, one why label, and the rationale for the selected labels. In detail, the model needs to select labels from the predefined taxonomy and return exactly one how and one why category. When the predefined taxonomy is insufficient

to explain the change, the model is allowed to suggest a new category as an extension. The detailed prompt for annotation is provided in our online appendix2.

Results

RQ1: The Current Status of Skill Evolution

RQ1.1: Main Components Distribution

1) RQ1.1: Main Components Distribution: The first research question aims to identify the main functional components that constitute agent skills. To answer this question, we apply the component taxonomy defined in Table I to the collected skills and quantify the occurrence of each component.

At the top level, Figure 4 shows that the three core components, i.e., metadata, workflow, and knowledge, appear in 99.9%, 98.2%, and 97.8% of skills, respectively. In contrast, resources are present in only 50.6% of skills, with code scripts appearing in only 14.6% of skills. These results suggest that skills are currently used primarily to structure prompts, procedural guidance, and domain knowledge. The relatively lower prevalence of code scripts further indicates that many skills do not package custom executable logic, and may instead rely more heavily on natural-language instructions, the agent’s general reasoning capabilities, and tools available in the execution environment.

Distribution of Major Skill Components

Figure 4. Distribution of Major Skill Components

At the fine-grained level, Figure 5 shows that 92.5% of skills contain functionality descriptions, while only 35.2% of skills include verification steps, and only 49.6% include recovery instructions for handling failures. This indicates that existing skills often lack support for reliable execution. A possible explanation is that developers primarily focus on the task specification and execution guidance, implicitly relying on the agent’s own execution capability and human intervention to handle failures, leaving verification and recovery overlooked in skill creation. Moreover, 28.9% of skills lack trigger conditions and 7.5% lack functionality descriptions, which may make it harder for agents to retrieve and select.

Distribution of Fine-Grained Skill Components

Figure 5. Distribution of Fine-Grained Skill Components

Findings 1: Skills are currently used primarily to structure prompts, procedural guidance, and domain knowledge. At the fine-grained level, they provide limited explicit quality assurance and failure-handling mechanisms. 36.4% of skills are incomplete in the metadata component, potentially hindering accurate retrieval by agents.

RQ1.2: Evolution Overview

We reconstruct the evolution history of each skill from repository commit histories. Among the collected skills, 64.3% have at least two valid commits. After applying the filtering criteria described in Section III-A, there are 84,200 skills with analyzable evolution histories for the following frequency and temporal analyses.

As shown in Figure 6(a), 58.5% of skills undergo fewer than five evolution events and 4% of skills undergo more than 20 evolution events, which suggests that most skills experience limited post-creation maintenance. We further inspect these frequently evolved skills and find that 86.9% of them are packages that include auxiliary documents, scripts, or project-specific resources. This pattern reveals that complex and project-coupled skills are more prone to be revised. As projects frequently update, skills also need to be updated, which imposes a high cost for manual skill maintenance. Figure 6(b) shows that 83.1% of consecutive evolution events occur within one week, while only 6.0% exceed one month. This indicates that developers often make rapid adjustments based on a skill’s early usage feedback until the skill becomes relatively stable.

Frequency and temporal rhythm of skill evolution

Figure 6. Frequency and Temporal Rhythm of Skill Evolution

Findings 2: 58.5% of skills experience limited maintenance, and frequent evolution is concentrated in a small

subset of complex and project-coupled skills, calling for future developers to focus on them and explore automated maintenance techniques that reduce developers’ maintenance cost. Skill evolution is also temporally concentrated, with most changes occurring within short-term windows.

RQ2: Modified Components in Skill Evolution

To analyze where skill modifications occur, we apply component-level change analysis described in III-C to actively evolved skills. Because applying this analysis to all skills is computationally expensive, we retain skills from repositories with more than 40 stars and skill files with more than 10 commits. The star threshold filters low-visibility repositories, while the commit-count threshold ensures sufficient evolution information for stable component-level analysis. This step results in 5,628 skills for the following analysis.

Figure 7 presents the distribution of changed major skill components. Workflow, knowledge, and metadata together account for 86.0% of all component-level changes. Among these components, workflow changes are the most frequent, accounting for 40.0% of all component-level changes, while resources and others together account for only 14.1%. One possible explanation is that resources and others are much less prevalent in skills, appearing in only about half as many skills as workflow (see Figure 4). Another reason may be that effective workflows usually require iterative refinement. This is further supported by the RQ4 result that Workflow Improvement accounts for 18.05% of all labeled changes.

Distribution of changed skill components

Figure 7. Distribution of Changed Skill Components

Findings 3: Among actively evolved skills, skill evolution is concentrated in instruction-oriented components.

At the fine-grained level, workflow execution (18.6%) and knowledge internal guidance (14.7%) are the most frequently modified subcomponents. The reasons may be that they directly shape agent execution. In contrast, verification (4.7%) and recovery (7.1%) are modified less frequently, suggesting that developers pay comparatively less attention to result-checking and failure-handling logic. Given the inherent ambiguity of skills as natural language artifacts and the stochastic nature of LLM-based execution [41, 42], the outcomes can be highly unpredictable. The reliability of skills is therefore a non-negligible concern for developers.

Findings 4: Fine-grained skill evolution mainly targets execution-oriented content, while reliability-oriented components often receive less attention from developers.

RQ3: Changed Patterns in Skill Evolution

Table II shows how developers modify skills during evolution. The most common change operation is Knowledge Enrichment (9.00%), followed by Workflow Refinement (8.50%), Traceable Metadata Change (7.59%), Knowledge Modification (7.34%), and Workflow Extension (6.14%), together accounting for 38.57% of all labeled changes. In contrast, developers modify skills through structural changes much less frequently. Knowledge Restructuring (1.74%), Workflow Integration (0.07%), and Artifact Refactoring (0.63%) together account for only 2.44% of all labeled changes. The relatively lower prevalence of structural changes suggests that developers are more likely to improve skills through incremental edits than by reorganizing their overall structure. One possible reason is that such changes are more likely to break or compromise skill functionality and often require more careful consideration.

How categoryShare
Knowledge Enrichment9.00%
Workflow Refinement8.50%
Traceable Metadata Change7.59%
Knowledge Modification7.34%
Workflow Extension6.14%
Knowledge Alignment5.37%
Format Alignment5.01%
Description Refinement4.93%
Workflow Modification4.47%
Metadata Refinement4.46%
Interface Alignment4.15%
Unnecessary Artifact Cleanup3.99%
Expression Simplification3.63%
Duplication Reduction3.44%
Resource Modification2.09%
Workflow Simplification2.07%
Workflow Alignment1.97%
Content Formalization1.89%
Knowledge Restructuring1.74%
Resource Alignment1.44%
Others10.79%

Table II. Distribution of Change Patterns.

Findings 5: Change patterns are dominated by incremental enrichment and refinement, while structural reorganization is rare.

It is also noted that simplification is a recurring maintenance behavior in skill evolution. Unnecessary Artifact Cleanup (3.99%), Expression Simplification (3.63%), Duplication Reduction (3.44%), and Workflow Simplification (2.07%) together account for 13.13% of all labeled changes. For example, 312362115/skills/deep-research removed the automatic update-check workflow that repeatedly ran after task completion to reduce redundant execution steps and unnecessary tool overhead. These changes suggest that developers sometimes encounter context-length pressure issues and attempt to simplify skill content by removing unnecessary artifacts, reducing duplicated instructions, and streamlining workflows.

Findings 6: Redundancy is a practical maintenance issue in skill evolution. Developers can simplify skills by removing unnecessary artifacts, reducing duplicated instructions, and streamlining workflows.

RQ4: Motivations of Skill Evolution

We investigate the intentions behind skill evolution by assigning a motivation label to each modified component (Section III-D), reporting both the top-level distribution and fine-grained categories.

As shown in the pie part of Figure 8, Perfective maintenance accounts for 50.37% of all changes, surpassing the sum of the other three types. This indicates that Perfective maintenance is the dominant motivation for skill evolution. The fine-grained motivations further support this tendency. Specifically, Completeness Improvement is the most frequent fine-grained motivation, accounting for 15.61% of all changes, followed by Knowledge Improvement (9.76%) and Retrieval Improvement (9.38%), which suggests that skills often require detailed task-related information and clearer retrieval cues after their initial release. One possible reason is that, unlike traditional software, skills are expressed in natural language with inherently ambiguous correctness boundaries, encouraging developers to continuously refine their skills. For example, 0xBigBoss/skills/tilt added a “Verifying Updates Applied” workflow with shell commands to check resource status and wait until resources are ready, thereby improving the completeness of the update process. naksha-studio/skills/design expanded the trigger condition with visualization keywords, making the skill more likely to be invoked for visualization-related requests.

Distribution of Motivations

Figure 8. Distribution of Motivations

Findings 7: Skill evolution is dominated by Perfective maintenance. This indicates that skills require continuous refinement to become functional, accurate, and invocable for agents after initial creation.

Moreover, we observe that security-related motivations appear relatively infrequently. To further contextualize this category, we conduct an auxiliary analysis of changes labeled as Security Enhancement, examining whether these security-motivated commits coincide with observable reductions in scanner-reported risks. We manually check the 1,156 Security Enhancement commits and retain 876 valid cases for analysis. Specifically, we use two publicly available skill security scanners, Cisco Skill Scanner [43] and Snyk Agent Scan [44], to scan for potential risks in skills. We analyze their outputs separately and use the number of reported high or critical risks as the main comparison metric. For each commit, we compare this number before and after the change: a commit is classified as Decreased, Unchanged, or Increased when the number of high-or-critical risks becomes smaller, remains the same, or becomes larger after the commit, respectively.

Table III shows that only a small portion of Security Enhancement commits are accompanied by a reduction in high-or-critical risk findings, with an average reduction rate of 13.01% across the two scanners. In contrast, most commits remain unchanged, and a few commits are even associated with an increase in risk findings. This suggests that most security-related changes do not lead to security improvements observable by existing skill-security scanners.

ScannerCommitsDecreasedUnchangedIncreased
Cisco876133 (15.2%)633 (72.3%)110 (12.5%)
Snyk87695 (10.8%)717 (81.8%)64 (7.3%)

Table III. Scanner Results for Security Enhancement commits after manual filtering.

Findings 8: Security-related skill changes rarely translate into observable scanner-confirmed risk reduction. This highlights a gap between developers’ security intent and actual security outcomes, underscoring the need for more effective automated tools to help developers make substantive improvements to skill security.

Discussions

Automated Annotation Accuracy

As described in Sections III-C and III-D, we first constructed the component taxonomy and the evolution pattern/motivation taxonomy based on manually inspected samples, and then used LLMs for large-scale automated annotation. To examine the reliability of the automated annotations, we report the manual annotation results for components, change patterns, and motivations, respectively, and cross-validate them against the model-generated annotations. Due to space limitations, we only report accuracy scores. Detailed results are provided in our online appendix2.

For component annotation, accuracy is computed at the Markdown-block level: we align blocks between the manual annotation and the model annotation within the same skill, and compare their assigned component labels. For change pattern and motivation annotation, we compute accuracy over changed components within each commit. Specifically, we first align changed components between the reference and model annotations. Then, for each aligned changed component, the “how” or “why” prediction is counted as correct only when it matches the reference label. Changes associated with unmatched components are treated as annotation errors. The reported accuracy is averaged over commits.

As shown in Table IV, the component annotation achieves an accuracy of 0.881, while the how and why annotations achieve accuracy scores of 0.816 and 0.840, respectively. These results indicate high agreement between model annotations and human annotations, supporting the reliability of the large-scale annotation results used in our analysis.

TaskUnitNAccuracy
Component (Section III-C)Skill3830.881
Component (Section III-D)Skill270.913
Change pattern (how)Commit4040.816
Fine-grained motivation (why)Commit4040.840

Table IV. Agreement between automated annotations and manual annotation labels. The first Component is sampled skills in RQ1.1, and the latter is the sampled skills in RQ2-4.

Research Opportunities

Based on our empirical findings, we summarize the following research opportunities:

Execution-contract skill design. RQ1 and RQ2 show that verification and recovery are both underrepresented in current skills and their evolution. This suggests that many skills still describe task procedures without specifying what agents should check results or handle failures. Due to the inherent ambiguity of skills as natural language artifacts and the stochastic nature of LLM-based execution, the outcome and procedure can be highly unpredictable. Future work could move beyond instruction-only skill design and define execution-contract schemas that include expected outputs, validation criteria, and recovery actions.

Automating just-in-time skill updating. RQ1.2 shows that frequent skill evolution is concentrated in a small subset of complex and project-coupled skills. As these skills are closely tied to project-specific contexts, they must be continuously updated to remain consistent with evolving codebases, dependencies, and tool interfaces. Such continuous synchronization can impose substantial maintenance costs when performed manually. These findings highlight the need for automated just-in-time skill updating mechanisms that can detect relevant project changes and adapt associated skills accordingly, thereby reducing developers’ maintenance burden.

Context-efficient skill representation. Simplification-related changes in RQ3 show that redundancy and accumulated complexity are practical maintenance issues. At the same time, every loaded skill competes with task history, observations, tool outputs, and retrieved documents for a limited agent context. This motivates compression and refactoring techniques that remove redundant or irrelevant content while preserving the semantics required for reliable execution.

Retrieval-aware skill engineering. Skill retrievability emerges as a recurring maintenance concern. RQ4 identifies Retrieval Improvement as one of the most frequent motivations. However, RQ1.1 shows that 28.9% of skills lack trigger conditions and 7.5% lack functionality descriptions, which may limit the precise retrieval of skills for a given task. Future work could build on our dataset to study automated techniques for improving skill retrievability, such as trigger-condition generation, functionality-description refinement, retrieval-keyword suggestion, and related-skill linking.

Context-alignment monitoring. RQ4 shows that a significant portion of changes aims to align skills with evolving execution contexts, involving updates to knowledge, formats, interfaces, workflows, and resources. This reflects the tight coupling between skills and their surrounding execution contexts, such as tools, data formats, and APIs. A promising direction is to monitor these contextual dependencies and detect when a skill becomes stale or inconsistent with the execution environment.

Skill regression testing. The scanner-based analysis in RQ4 shows a gap between security intent and security effect: security-motivated commits do not always reduce risks, and some even increase them. This calls for regression testing methods that evaluate skill behavior before and after a change. Possible tests include replaying representative tasks and checking whether the success rate, safety, retrieval accuracy, or execution cost degrades.

Pattern-guided skill enhancer. RQ4 shows that skill evolution is dominated by Perfective maintenance, indicating that many skills are functional but still incomplete, under-specified, or difficult to use effectively. This creates an opportunity for pattern-guided skill enhancers. Such tools could diagnose weak components, such as missing trigger conditions, sparse verification steps, incomplete recovery logic, or insufficient domain knowledge, and recommend component-level edits based on common evolution patterns.

Agent skills are moving from isolated markdown files toward shared and maintained capability artifacts. Recent skill markets and community repositories suggest a trajectory similar to software ecosystems: from ad hoc scripts, to reusable components, and eventually to maintained ecosystems. In such an ecosystem, skill evolution is not simply editing documentation, but the basis for keeping skills usable, reliable, and accountable as tasks, tools, and environments change. Our study shows that current skill evolution is active but still immature, with many changes focusing on refinement and completeness, while verification, recovery, long-term feedback, and security remain underdeveloped. This suggests that future skill ecosystems need maintenance infrastructure built around four properties: skills should be triggerable for correct retrieval, attributable in terms of why they change, localizable when failures occur, and traceable across their evolution history. By characterizing what, how, and why skills evolve, our work provides an empirical foundation for building such reliable and maintainable skill ecosystems.

Threats to Validity

Internal Validity. Our component-level analysis relies on model-based identification of components and their subsequent “how”/“why” annotations. To mitigate this, we first constructed the component and evolution taxonomies from manually inspected samples, used structured prompts with predefined label spaces, and evaluated automated annotations against manually labeled reference data. The annotation accuracy scores for component, change-pattern, and motivation labels are 0.913, 0.816, and 0.840, respectively, suggesting that the automated annotations are reasonably reliable.

External Validity. Our dataset is collected from public GitHub repositories, and the findings may not fully generalize to private skills or enterprise settings. Nevertheless, GitHub is the largest open-source code hosting platform, and public agent skill repositories represent the mainstream practices of the developer community. In addition, the findings of RQ2–RQ4 are based on relatively active and visible skills, and may not fully generalize to low-activity skills or skills from less visible repositories. Nevertheless, skills with fewer evolution events provide limited evidence for fine-grained evolution analysis; focusing on actively evolved skills ensures sufficient change samples for reliable component-level analysis.

Conclusion

This study systematically analyzes the evolution characteristics of real-world agent skills. We present the current status of skills and conduct a fine-grained investigation along three dimensions: modified components, change patterns, and evolution motivations. Using data mining, open coding, semantic annotation, and statistical analysis, we identify several findings. Agent skills currently lack sufficient attention to reliability and failure handling in both their composition and evolution. Evolution changes concentrate in a small subset of project-coupled skills, while modified content skews toward instruction-oriented and perfective improvements. Change patterns are dominated by incremental enrichment and refinement, and redundancy emerges as a recurring maintenance issue. Security-motivated changes rarely translate into observable risk reduction, revealing a persistent gap between developer intent and actual security outcomes. These findings also motivate several future research opportunities: execution-contract skill design, automated skill update and refinement, skill regression testing, context-efficiency skill representation, retrieval-aware engineering, and context monitoring. By releasing our research dataset, future work could develop techniques for improving the quality, reliability, and maintainability of agent skills.

DATA AVAILABILITY

Our data, code, and online appendix are available at https://github.com/ZJU-CTAG/SkillEMP.

ACKNOWLEDGMENT

This research is supported by the National Natural Science Foundation of China (No.92582107), the Fundamental Research Funds for the Central Universities (No. 226-2025-00067), and the University Grants Committee / Research Grants Council (General Research Fund 16210725 and Theme-based Research Scheme T41-517_25-N).

References

References

  1. [1]T. Raheem and G. Hossain, “Agentic ai systems: Opportunities, challenges, and trustworthiness,” in 2025 IEEE International Conference on Electro Information Technology (EIT), 2025, pp. 618–624.DOI
  2. [2]S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, “React: Synergizing reasoning and acting in language models,” arXiv preprint arXiv:2210.03629, 2022.arxiv.org/abs/2210.03629
  3. [3]F. F. Xu, Y. Song, B. Li, Y. Tang, K. Jain, M. Bao, Z. Wang, X. Zhou, Z. Guo, M. Cao et al., “Theagentcompany: benchmarking llm agents on consequential real world tasks,” Advances in Neural Information Processing Systems, vol. 38, 2026.arxiv.org/abs/2412.14161
  4. [4]X. Liu, H. Yu, H. Zhang, Y. Xu, X. Lei, H. Lai, Y. Gu, H. Ding, K. Men, K. Yang et al., “Agentbench: Evaluating llms as agents,” in International Conference on Learning Representations, vol. 2024, 2024, pp. 52989–53046.arxiv.org/abs/2308.03688
  5. [5]C. S. Xia, Y. Wei, and L. Zhang, “Automated program repair in the era of large pre-trained language models,” in 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), 2023, pp. 1482–1494.DOI
  6. [6]C. Lemieux, J. P. Inala, S. K. Lahiri, and S. Sen, “Codomosa: Escaping coverage plateaus in test generation with pre-trained large language models,” in 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), 2023, pp. 919–931.DOI
  7. [7]S. Kang, J. Yoon, and S. Yoo, “Large language models are few-shot testers: Exploring llm-based general bug reproduction,” in 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE, 2023, pp. 2312–2323.arxiv.org/abs/2209.11515
  8. [8]I. Bouzenia and M. Pradel, “Understanding software engineering agents: A study of thought-action-result trajectories,” in 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 2025, pp. 2846–2857.
  9. [9]X. Du, L. Li, D. Zhang, and L. Song, “Memr³: Memory retrieval via reflective reasoning for llm agents,” arXiv preprint arXiv:2512.20237, 2025.
  10. [10]W. Xu, Z. Liang, K. Mei, H. Gao, J. Tan, and Y. Zhang, “A-mem: Agentic memory for llm agents,” arXiv preprint arXiv:2502.12110, 2025.arxiv.org/abs/2502.12110
  11. [11]Z. Tan, Y. Yan, I.-H. Hsu, R. Han, Z. Wang, L. Le, Y. Song, Y. Chen, H. Palangi, G. Lee et al., “In prospect and retrospect: Reflective memory management for long-term personalized dialogue agents,” in Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 2025, pp. 8416–8439.arxiv.org/abs/2503.08026
  12. [12]Anthropic, “Equipping agents for the real world with skills,” https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills, 2025.
  13. [13]W. Su, J. Long, Q. Ai, Q. He, Y. Tang, C. Wang, Y. Tu, Y. Wang, and Y. Liu, “Skill retrieval augmentation for agentic ai,” arXiv preprint arXiv:2604.24594, 2026.arxiv.org/abs/2604.24594
  14. [14]Y. Yang, J. Li, Q. Pan, B. Zhan, Y. Cai, L. Du, J. Zhou, K. Chen, Q. Chen, X. Li et al., “Autoskill: Experience-driven lifelong learning via skill self-evolution,” arXiv preprint arXiv:2603.01145, 2026.arxiv.org/abs/2603.01145
  15. [15]C. S. Xia, Y. Deng, S. Dunn, and L. Zhang, “Demystifying llm-based software engineering agents,” Proceedings of the ACM on Software Engineering, vol. 2, no. FSE, pp. 801–824, 2025.DOI
  16. [16]I. Bouzenia and M. Pradel, “You name it, i run it: An llm agent to execute tests of arbitrary projects,” Proceedings of the ACM on Software Engineering, vol. 2, no. ISS TA, pp. 1054–1076, 2025.arxiv.org/abs/2412.10133
  17. [17]R. Xu and Y. Yan, “Agent skills for large language models: Architecture, acquisition, security, and the path forward,” arXiv preprint arXiv:2602.12430, 2026.arxiv.org/abs/2602.12430
  18. [18]G. Ling, S. Zhong, and R. Huang, “Agent skills: A data-driven analysis of claude skills for extending large language model functionality,” arXiv preprint arXiv:2602.08004, 2026.arxiv.org/abs/2602.08004
  19. [19]Y. Liu, W. Wang, R. Feng, Y. Zhang, G. Xu, G. Deng, Y. Li, and L. Zhang, “Agent skills in the wild: An empirical study of security vulnerabilities at scale,” arXiv preprint arXiv:2601.10338, 2026.arxiv.org/abs/2601.10338
  20. [20]A. Zhao, D. Huang, Q. Xu, M. Lin, Y.-J. Liu, and G. Huang, “Expel: Llm agents are experiential learners,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 38, no. 17, 2024, pp. 19629–19642.arxiv.org/abs/2308.10144
  21. [21]S. Zhang, J. Zhang, J. Liu, L. Song, C. Wang, R. Krishna, and Q. Wu, “Offline training of language model agents with functions as learnable weights,” in Forty-first International Conference on Machine Learning, 2024.arxiv.org/abs/2402.11359
  22. [22]Z. Z. Wang, J. Mao, D. Fried, and G. Neubig, “Agent workflow memory,” in International Conference on Machine Learning. PMLR, 2025, pp. 63 897–63 911.arxiv.org/abs/2409.07429
  23. [23]Y. Zhou, W. Shu, Y. Su, W. Du, Y. Fang, and X. Lin, “A comprehensive survey on agent skills: Taxonomy, techniques, and applications,” arXiv preprint arXiv:2605.07358, 2026.arxiv.org/abs/2605.07358
  24. [24]Y. Liang, R. Zhong, H. Xu, C. Jiang, Y. Zhong, R. Fang, J.-C. Gu, S. Deng, Y. Yao, M. Wang et al., “Skillnet: Create, evaluate, and connect ai skills,” arXiv preprint arXiv:2603.04448, 2026.arxiv.org/abs/2603.04448
  25. [25]H. Li, C. Mu, J. Chen, S. Ren, Z. Cui, Y. Zhang, L. Bai, and S. Hu, “Organizing, orchestrating, and benchmarking agent skills at ecosystem scale,” arXiv preprint arXiv:2603.02176, 2026.arxiv.org/abs/2603.02176
  26. [26]J. Ni, Y. Liu, X. Liu, Y. Sun, M. Zhou, P. Cheng, D. Wang, E. Zhao, X. Jiang, and G. Jiang, “Traceskill: Distill trajectory-local lessons into transferable agent skills,” arXiv preprint arXiv:2603.25158, 2026.
  27. [27]Y. Zheng, Z. Zhang, C. Ma, Y. Yu, J. Zhu, Y. Wu, T. Xu, B. Dong, H. Zhu, R. Huang et al., “Skillrouter: Skill routing for llm agents at scale,” arXiv preprint arXiv:2603.22455, 2026.arxiv.org/abs/2603.22455
  28. [28]D. Liu, Z. Li, H. Du, X. Su, Gui, Y. Kuang, and L. Sun, “Graph of skills: Dependency-aware structural retrieval for massive agent skills,” arXiv preprint arXiv:2604.05333, 2026.arxiv.org/abs/2604.05333
  29. [29]K. Zeng, Y. Huo, S. Zhang, Z. Ye, Y. Zhuo, H. Liu, Y. Lu, J. Wen, and X. Tang, “Group of skills: Group-structured skill retrieval for agent skill libraries,” arXiv preprint arXiv:2605.06978, 2026.arxiv.org/abs/2605.06978
  30. [30]H. Pu, X. Song, and L. Zhao, “Skillops: Managing llm agent skill libraries as self-maintaining software ecosystems,” arXiv preprint arXiv:2605.13716, 2026.arxiv.org/abs/2605.13716
  31. [31]H. Zhang, S. Fan, H. P. Zou, Y. Chen, Z. Wang, J. Zhou, C. Li, W.-C. Huang, Y. Yao, K. Zheng et al., “Coevoskills: Self-evolving agent skills via co-evolutionary verification,” arXiv preprint arXiv:2604.01687, 2026.arxiv.org/abs/2604.01687
  32. [32]Z. Li and Y. Hu, “Skillhone: A harness for continual agent skill evolution through persistent decision history,” arXiv preprint arXiv:2606.08671, 2026.arxiv.org/abs/2606.08671
  33. [33]Y. Liu, Z. Chen, Y. Zhang, G. Deng, Y. Li, J. Ning, Y. Zhang, and L. Y. Zhang, “Malicious agent skills in the wild: A large-scale security empirical study,” arXiv preprint arXiv:2602.06547, 2026.
  34. [34]GH Archive, “GH archive: Github activity dataset,” https://www.gharchive.org, 2012, accessed: 2026-04-23.
  35. [35]Anthropic, “Agent skills specification,” https://github.com/agentskills/agentskills, 2026, accessed: 2026-05-19.
  36. [36]H. Yang and H. Cai, “Dissecting real-world cross-language bugs,” Proc. ACM Softw. Eng., vol. 2, no. FSE, Jun. 2025. [Online]. Available: https://doi.org/10.1145/3715777
  37. [37]W. Charoenwet, P. Thongtanunam, V.-T. Pham, and C. Treude, “An empirical study of static analysis tools for secure code review,” in Proceedings of the 33rd ACM SIGSOFT international symposium on software testing and analysis, 2024, pp. 691–703.arxiv.org/abs/2407.12241
  38. [38]A. Xu, B. Lin, B. Xue, B. Wang, B. Xu, B. Wu, B. Zhang, C. Lin, C. Dong, C. Ling et al., “Deepseek-v4: Towards highly efficient million-token context intelligence,” arXiv preprint arXiv:2606.19348, 2026.arxiv.org/abs/2606.19348
  39. [39]E. B. Swanson, “The dimensions of maintenance,” in Proceedings of the 2nd International Conference on Software Engineering, 1976, pp. 492–497.DOI
  40. [40]ISO/IEC/IEEE 14764:2022 Systems and Software Engineering – Software Life Cycle Processes – Maintenance, International Organization for Standardization Std., 2022.
  41. [41]S. Ouyang, J. M. Zhang, M. Harman, and M. Wang, “An empirical study of the non-determinism of chatgpt in code generation,” ACM Transactions on Software Engineering and Methodology, vol. 34, no. 2, pp. 1–28, 2025.DOI
  42. [42]S. Vijayvargiya, X. Zhou, A. Yerukola, M. Sap, and G. Neubig, “Interactive agents to overcome ambiguity in software engineering,” arXiv preprint arXiv:2502.13069, 2025.arxiv.org/abs/2502.13069
  43. [43]Cisco AI Defense, “Skill scanner,” https://github.com/cisco-ai-defense/skill-scanner, 2026, accessed: 2026-06-15.
  44. [44]Snyk, “Agent scan,” https://github.com/snyk/agent-scan, 2026, accessed: 2026-06-15.

Paper details

vlnc:W_9pmuxtv2
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 23

downloads · 5

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents