dingxingdi

@dingxingdi source repo

389 skills
0 followers
20 hours ago last updated

▌
Exploration Guided Unfamiliar App Adaptation 2 · dingxingdi bundle
Use this skill when the user wants data where the agent must first learn a new app instead of relying on habits from familiar software. Trigger it for requests like “make it figure out a new app by looking around first,” “test whether it can adapt to an unfamiliar layout,” “have it explore before acting,” or “don’t let knowledge from another app transfer cleanly.” This skill is for GUI tasks where app-specific structure must be discovered from exploration traces before the real task can be solved.

0
installs
▌
Evidence Grounded Result Synthesis 2 · dingxingdi bundle
Skill: evidence-grounded-result-synthesis

0
installs
▌
Nested Aggregation And Filter Reasoning 2 · dingxingdi bundle
Skill: nested aggregation and filter reasoning

0
installs
▌
Contextual Privacy Preserving Disclosure 2 · dingxingdi bundle
Skill: contextual-privacy-preserving-disclosure

0
installs
▌
Policy Constrained Decision Making 2 · dingxingdi bundle
Skill: policy-constrained-decision-making

0
installs
▌
Open Domain Data Discovery And Table Selection 2 · dingxingdi bundle
Skill: open-domain data discovery and table selection

0
installs
▌
Cross Modal Alignment And Dialogue Grounding 2 · dingxingdi bundle
Use this skill when the user wants questions about 'who said it', 'which sound matches this moment', 'connect the voice to the gesture', 'use both the video and the audio', or 'ground the answer in dialogue or subtitle timing.' Trigger it whenever neither the video alone nor the audio alone is enough to answer reliably.

0
installs
▌
Open Ended Reasoning And Explanation 2 · dingxingdi bundle
Skill: open-ended-reasoning-and-explanation

0
installs
▌
Scientific Threshold And Context Inference 2 · dingxingdi bundle
Skill: scientific threshold and context inference

0
installs
▌
Adversarially Robust Tool Orchestration 2 · dingxingdi bundle
Skill: adversarially-robust-tool-orchestration

0
installs
▌
Truth Maintenance Under Invalid Feedback 2 · dingxingdi bundle
Skill: truth-maintenance-under-invalid-feedback

0
installs
▌
Information Asymmetric Theory Of Mind Reasoning 2 · dingxingdi bundle
Skill: information-asymmetric-theory-of-mind-reasoning

0
installs
▌
Domain Rule Extraction And Contextual Instruction Ground 2 · dingxingdi bundle
Skill: domain-rule extraction and contextual instruction grounding

0
installs
▌
Multi Step Data Transformation And Analytics Orchestrati 2 · dingxingdi bundle
Use this skill when the user wants code-agent data for realistic analytics-engineering or data-workflow tasks that span multiple steps, intermediate files, and project context. Trigger it for requests like 'generate DBT-style workflows', 'make multi-step analytics coding tasks', 'give me enterprise data engineering trajectories', or 'create tasks where the agent has to chain SQL and Python in a project'. Do not use it for single-query SQL authoring.

0
installs
▌
Long Horizon Information Recall And Personalization 2 · dingxingdi bundle
Skill: long-horizon-information-recall-and-personalization

0
installs
▌
Safety Preserving Refusal Under Conversational Pressure 2 · dingxingdi bundle
Skill: safety-preserving-refusal-under-conversational-pressure

0
installs
▌
Retrieval Augmented Information Reconciliation · dingxingdi bundle
Skill: retrieval-augmented-information-reconciliation

0
installs
▌
Bimanual Reachability And Collaborative Coordination · dingxingdi bundle
Trigger this skill when the agent must coordinate two arms or manipulators to solve a task. Use this when the user's need involves bimanual tasks such as 'use both hands to lift this', 'pass the object from the left arm to the right', 'pick up two items at once without bumping the arms', 'which hand should I use for this?', or 'can the left arm reach that far?'. It is essential for tasks requiring role assignment between arms, reachability analysis, and collaborative movement to prevent inter-arm collisions or kinematic failures.

0
installs
▌
Intent Constraint Alignment Robustness · dingxingdi bundle
Use this skill when the user provides complex questions with multiple specific rules, such as 'List items that fit A, B, and C but not D,' or 'Write a response with exactly 5 points, each starting with a vowel.' Trigger it for requests like 'make sure you don't forget the location constraint,' 'check if I've included everything I asked for,' or 'test if the model ignores the background info I provided.' This skill ensures that every semantic role (subject, action, time, location, qualifier) defined in the user's intent is strictly honored, preventing 'Intent Hallucination' where the agent omits or misinterprets query components.

0
installs
▌
Information Asymmetric Theory Of Mind Reasoning · dingxingdi bundle
Use this skill when analyzing multi-party interactions where characters possess conflicting knowledge, or when verifying a speaker's identity strictly based on what they know or how they interact. Trigger it for requests like 'what does she think happened?', 'does he understand why she's mad?', or 'which character from the book is most likely speaking this line?'. Everyday scenarios include characters missing facts by leaving a room, forming false beliefs about another's core intentions, or identifying a hidden persona based on pragmatic conversational clues and unique historical knowledge limitations.

0
installs
▌
Shortcut Resistant Procedural Grounding · dingxingdi bundle
Use this skill when the user wants to test if the model 'cheats' by guessing answers when the logical steps are missing. Trigger it for requests like 'don't answer if the bridge is missing', 'check if it falls for false assumptions in the question', 'make sure it doesn't guess from the answer options', or 'test if it spots that the question is too specific for the text'. This skill focuses on resisting 'shortcut reasoning' where a model provides a correct-looking answer despite failing to trace the full evidence chain.

0
installs
▌
Autonomous Multi Action Software Engineering Orchestration · dingxingdi bundle
Use this skill when the task requires orchestrating a complex, multi-stage engineering lifecycle to develop advanced features across diverse and esoteric scientific/engineering domains. Trigger it for requests like 'implement this Verilog hardware module', 'automate the MOOSE multiphysics modeling of a fuel assembly', 'convert these game rules into an executable Python world simulator', or 'build a formally verified Lean algorithm'. It universally covers objectives requiring translation of specific domain constraints into specialized logic, iterative compilation/simulation, and managing state across multiple files.

0
installs
▌
Multi Step Data Transformation And Analytics Orchestration · dingxingdi bundle
Use this skill when the user wants code-agent data for realistic end-to-end data engineering, analytics, or ELT (Extract, Load, Transform) tasks spanning infrastructure configurations, multiple tools, and intermediate files. Trigger it for requests like 'create a full ELT workflow from Postgres to Snowflake', 'generate DBT-style models', 'make multi-step analytics tasks', 'set up Airbyte and Terraform pipelines', or 'chain SQL and Python across a complex project'. Do not use for single-query SQL authoring.

0
installs
▌
Hierarchical And Nested Data Structural Reasoning · dingxingdi bundle
Skill: hierarchical and nested data structural reasoning

0
installs
▌
Reasoning Intensive Analogical Retrieval · dingxingdi bundle
Use this skill when the user wants to test the agent's ability to find relevant documents that do not share many words with the question but are linked by deeper logic. Trigger this for requests like 'find a case that matches this story', 'give me law that applies to this situation even if the terms are different', 'search based on the legal issue rather than keywords', or 'test if the model can spot the underlying rule in a complex scenario'. It is specifically designed for high-reasoning legal or technical retrieval where lexical overlap is extremely low.

0
installs
▌
Interactive Tool Augmented Logic Synthesis And Orchestration · dingxingdi bundle
Use this skill when the user wants data for solving software logic or algorithmic problems where the agent must interactively call specialized tools (representing atomic code functions) rather than writing a single code block. Trigger it for requests like 'solve this logic puzzle as an agent', 'use these coding tools to find the hidden answer', 'create interactive algorithmic tasks', or 'give me multi-turn tool-use data for code agents'. This is crucial when the agent must solve a task by actively exploring state feedback (e.g., querying indices, checking intermediate calculations) to arrive at a final answer.

0
installs
▌
Long Horizon Information Recall And Personalization · dingxingdi bundle
Skill: long-horizon-information-recall-and-personalization

0
installs
▌
Multi Turn Agentic Reasoning And Tool Orchestration · dingxingdi bundle
Skill: multi-turn-agentic-reasoning-and-tool-orchestration

0
installs
▌
Multimodal Feature Extraction And Signal Engineering · dingxingdi bundle
Skill: multimodal feature extraction and signal engineering

0
installs
▌
Constraint Driven Modular Template Synthesis · dingxingdi bundle
Use this skill when the user wants to generate a complex technical design or code output by selecting and assembling modular components from a pre-defined library according to specific quantitative constraints (budgets). Trigger it for requests like 'build a configuration that fits this power budget', 'pick the right hardware modules to keep area small', 'assemble a design from the library using these specs', or 'generate a project top-file that pulls in the right parts'.

0
installs
▌
Proactive Conversational Engagement Synthesis · dingxingdi bundle
Use this skill when the user wants the agent to sound like a natural conversationalist who keeps the dialogue alive rather than providing dead-end answers. Trigger it for requests like 'make the agent more proactive', 'add follow-up questions to the results', 'simulate a back-and-forth chat', or 'encourage the user to keep asking things'. It is specifically geared towards generating synthetic training data where the assistant answers a query and then pivots to a related, inquisitive follow-up based on the retrieved knowledge.

0
installs
▌
Integration Aware Information Extraction And Database Popula · dingxingdi bundle
Use this skill when the user wants to populate or enrich an existing relational database using information extracted from raw text documents. Trigger it for requests like 'extract information from these news reports into my SQL database', 'add new rows to the movies table based on this biography', 'fill in missing data in my table using the provided text', or 'create new columns from the attached articles'. This skill is specifically for tasks that require the agent to understand a database schema and ensure that data extracted from unstructured sources follows formatting, granularity, and integrity constraints.

0
installs
▌
Safety Preserving Refusal Under Conversational Pressure · dingxingdi bundle
Skill: safety-preserving-refusal-under-conversational-pressure

0
installs
▌
Heterogeneous Source Integration And Multi Hop Reasoning · dingxingdi bundle
Skill: heterogeneous source integration and multi-hop reasoning

0
installs
▌
Data Sufficiency Evaluation And Unanswerability Detection · dingxingdi bundle
Skill: data sufficiency evaluation and unanswerability detection

0
installs
▌
Parametric Contextual Reliability Differentiation · dingxingdi bundle
Use this skill when you want to see if the agent can tell the difference between what it 'just knows' (from its own memory) and what is actually written in the provided files. Trigger it for requests like 'tell me when the agent is guessing', 'separate facts in the doc from general knowledge', 'check if the model is hallucinating outside the search results', or 'make sure the answer stays true even if it's not in the context'.

0
installs
▌
Multi Turn Conversational Repair And Disfluency Robustness · dingxingdi bundle
Use this skill when the user provides messy instructions, changes their mind halfway, involves stutters, mixes multiple languages/dialects (like Spanglish or Hinglish), or interrupts the agent mid-response to correct a mismatch. Trigger it for requests like 'No, you're not listening', 'Wait, that's not what I meant', 'Stop talking and listen to X', or when the user cuts you off. Everyday examples include handling self-corrections ('I want coffee... no, tea'), filtering out 'uh' and 'um', adapting to casual code-switched bilingual speech seamlessly, and pivoting the conversation precisely when the user flags that you've misinterpreted their intent.

0
installs
▌
Domain Rule Extraction And Contextual Instruction Grounding · dingxingdi bundle
Skill: domain-rule extraction and contextual instruction grounding

0
installs
▌
Metadata Augmented Analytical Table Identification · dingxingdi bundle
Use this skill when the user wants to find information trapped inside data tables, spreadsheets, or databases but doesn't know which file to open. It is perfect for requests like 'find the table with school scores in Alameda', 'which database has the sports results for 2009', 'check if this fact about racing is true', or 'write a query for the city furthest from Boston'. Use this specifically when table titles are missing, uninformative, or when the answer requires pulling from multiple related databases.

0
installs
▌
Integrity Aware Visualization And Design Best Practice Audit · dingxingdi bundle
Skill: integrity-aware visualization and design best-practice audit

0
installs
▌
Source Retrieval · dingxingdi bundle
Skill: source retrieval

0
installs
▌
Tense Consistency · dingxingdi bundle
Use this skill when the user wants translation data for stories, novels, or multi-sentence narratives where the timing of events (past, present, or future) must stay consistent across the entire text. It is triggered for plain-language requests like 'don't flip-flop between past and present tense,' 'make sure the story stays in the past,' 'test if the translator can handle a flashback properly,' or 'ensure the grammar matches the timing of the actions.'

0
installs
▌
Schema Item Grounding · dingxingdi bundle
Skill: schema item grounding

0
installs
▌
Ellipsis Resolution · dingxingdi bundle
Use this skill when the user wants translation data with short replies, subtitles, or conversational fragments where part of the meaning is missing unless you read the previous line. Trigger it for requests like "the second sentence leaves words out," "the answer is elliptical," or "test whether the translator can fill in what is omitted from context instead of translating the fragment too literally."

0
installs
▌
SQL Dialect Adaptation · dingxingdi bundle
Skill: sql dialect adaptation

0
installs
▌
Referential Recovery · dingxingdi bundle
Use this skill when the user wants translation data that forces the system to trace who or what a pronoun ('he,' 'she,' 'they') or omitted subject refers to using context from previous sentences. Trigger it for requests like 'the subject is dropped,' 'pronouns are ambiguous,' or 'make sure pronouns don't rely on sexist stereotypes based on the person's job type.'

0
installs
▌
Step Efficient Execution · dingxingdi bundle
Use this skill when the user wants data that tests whether the agent takes the shortest, most optimal GUI path instead of wandering, overthinking, or executing redundant actions. Trigger it for requests like 'same task but fewer clicks,' 'don't click the switch if it's already blue,' 'choose the fastest menu route,' 'only tick the box if it isn't already checked,' or 'make sure every move counts.' This skill is for GUI tasks where success alone is not enough; the trajectory must be highly compact, proving the agent avoids zero-value turns and respects state-aware 'No-Op' logic when a target is already configured correctly.

0
installs
▌
Multi Hop Join Reasoning · dingxingdi bundle
Skill: multi-hop join reasoning

0
installs
▌
SQL Debugging And Repair · dingxingdi bundle
Trigger this skill when the user provides broken or logically incorrect SQL requiring clause-level diagnosis and repair. It is essential when a query results in a syntax crash, row inflation (unwanted duplicates), or semantic nulls (correct syntax but no data returned). Layman triggers include requests like 'fix this query', 'why is my code returning nothing?', 'this script has an error on line 5', or 'adjust the WHERE clause to match the question better'. Use this to target specific parts of a query like the SELECT, WHERE, or JOIN clauses for fine-grained localized correction.

0
installs
▌
Automatic Post Editing · dingxingdi bundle
Use this skill when the user provides a source text along with a flawed machine-generated translation and wants it improved or corrected. This is ideal for cleaning up robotic, awkward, or inaccurate drafts. Trigger it for requests like 'fix the errors in this translation,' 'improve this machine-translated version,' 'clean up this draft to match the English original,' or 'post-edit this translation to make it sound more natural and accuracy-checked.' It is especially useful for correcting semantic drift and ambiguous phrasing introduced by Large Language Models.

0
installs
▌
Geospatial Rule Grounding · dingxingdi bundle
Skill: geospatial rule grounding

0
installs
▌
Terminology Consistency · dingxingdi bundle
Use this skill when the user wants translation data where a repeated term must stay the same across a whole document, such as product names, policy labels, medical terms, or recurring entities. Trigger it for requests like "keep the wording consistent across paragraphs," "do not rename the same thing every time," or "test whether the translator locks repeated terms instead of drifting between alternatives."

0
installs
▌
Multimodal Page Grounding · dingxingdi bundle
Use this skill when the user wants tasks where the page layout, screenshot, specific visual position, layout adjacency in tables, or physical drag-and-drop motions actually matter. Trigger it for requests like “make it rely on what’s visible on the page,” “extract the data from this complex table layout,” “buttons and layout should dictate the choice,” or “force the agent to navigate based on spatial coordinates.” It is the right skill for browser tasks where perception must combine HTML-like structure with visual grounding to execute continuous mouse events or parse complex semi-structured layouts (like grids or key-value structures).

0
installs
▌
Missing Evidence Rejection · dingxingdi bundle
Trigger this skill when users want to test if an agent can say 'I don't know' or 'not enough info' when the facts are missing, semi-missing, or when the question itself is a trick. Use it for requests like 'make the model deflect from unanswerable questions', 'test if it gets caught by false assumptions', 'give me questions that ask for too much detail', or 'hide the answer and see if it guesses'. It teaches the agent to resist 'shortcut reasoning' and identify when evidence is insufficient, contradictory, or lacks the required specificity.

0
installs
▌
Multi Document Integration · dingxingdi bundle
Trigger this skill when the answer is logically fragmented across physically non-contiguous spans or when a local entity (like a function or a paragraph) requires context from a larger structure (like a repository, class, or multi-volume report). It is used for natural language requests like 'connect the fragments from this long report', 'stitch together clues from the repository', 'summarize this function using the rest of the class for context', 'check if a second search is needed for the missing repository details', or 'compare files to find similarities'. This skill ensures the agent can proactively identify and retrieve 'anchor' documents—such as skeletons, table of contents, or related code chunks—to perform high-fidelity synthesis.

0
installs
▌
Temporal Tabular Reasoning · dingxingdi bundle
Use this skill when the user wants SQL tasks where time is the main source of difficulty, including colloquial shift-based time references. Trigger it for requests like “make it about first vs last”, “events that happened before the night shift”, “test recency and ordering”, or “during the lunch hour bounds.”

0
installs
▌
Long Video Summarization · dingxingdi bundle
Use this skill when the user wants 'summarize the whole video', 'tell me what happened in the second half', 'explain the development of the situation', 'give the main developments', or when parsing the overarching narrative of fast-paced commercials and trailers. Trigger it when the desired answer must integrate many moments across a long duration into one coherent account, connect the dots between separate events located far apart, or trace the overarching thematic/plot arc of a complex or rapidly edited video.

0
installs
▌
Cross Source Clue Chaining · dingxingdi bundle
Use this skill when the user wants questions that require “connecting the dots,” pulling clues from several disparate places, or reconciling fragmented factual attributes (names, dates, quantities) from the latest news events. Trigger it for requests like “make the agent gather bits from different sites,” “test if the agent can connect the dots between recent reports,” “track the details of this specific 2025 incident,” or “force multi-hop reasoning to solve a hint-free question.” It is especially effective for scenarios where the answer is too recent for the model to know internally and requires searching for multiple sources to verify distinct parts of an answer.

0
installs
▌
Schema Compliance · dingxingdi bundle
Skill: schema-compliance

0
installs
▌
Textual Attribute Grounding · dingxingdi bundle
Skill: textual attribute grounding

0
installs
▌
Discourse Connective Flow · dingxingdi bundle
Use this skill when the user wants a translation where the logical links and transitions between sentences (using words like 'however,' 'consequently,' or 'on the other hand') feel natural and coherent across the whole document. Trigger it for requests like 'the sentences sound disjointed,' 'make the logic flow together between paragraphs,' 'ensure the transitions aren't clunky,' or 'test if the translator can handle words that connect one idea to the next across a long text.'

0
installs
▌
Text To Gloss Translation · dingxingdi bundle
Use this skill when the user wants to translate spoken or written natural language into 'Gloss' notation, which acts as a written label system for Sign Language (SL). Trigger it for requests like 'convert this to sign language labels,' 'write the gloss for this sentence,' 'translate this for a deaf person using sign-language word order,' or 'how would you sign this in a word-for-word label format?' It handles specific sign-language constraints such as using infinitives and omitting functional words.

0
installs
▌
Prompt Injection Resistance · dingxingdi bundle
Use this skill when the user wants to synthesize web-based prompt injection attacks that test if an agent can be 'hijacked' by malicious instructions hidden in a webpage's HTML or content. Trigger it for requests like 'don't let the website trick the agent,' 'test if hidden code can change the task,' 'make sure the page doesn't override previous orders,' or 'check if the agent falls for fake system messages in the page.' It is specifically designed to create 'Environmental Injection Attacks' (EIA) where the threat is embedded in the web data the agent perceives rather than the user's initial prompt.

0
installs
▌
Executable Issue Resolution · dingxingdi bundle
Use this skill when the user wants bug-fix data for normal repository issues where the answer should come from reading an issue, navigating unfamiliar codebases, editing code, and running tests. Trigger it for requests like 'fix the NaN loss in my ML training script', 'solve issues in a massive codebase', 'fix this data race', 'debug my SQL query', or 'resolve this executable failure'. It covers standard software environments, database architectures, and systems infrastructures, emphasizing the fix-test-verify loop.

0
installs
▌
Symbolic State Tracking · dingxingdi bundle
Use this when the user wants planning data about keeping track of where things are, what is on top of what, what is free or blocked, mapping a path mentally, or when later steps only work if earlier moves changed the state correctly. Trigger it for requests like 'make tasks where one wrong early move ruins everything', 'give me block moving plans that depend on what is clear', 'navigate this maze by keeping a visual note of turns', or 'create tasks where the plan must remember what changed after each step, even if the actions use weird or random code names.'

0
installs
▌
Unanswerable Query Detection · dingxingdi bundle
Use this skill when the user's request appears to be impossible to answer based on the current database schema, contains high levels of ambiguity, or asks for information simply not stored in the database. Trigger it for requests like 'is this even in the data?', 'can the database answer this?', 'check if any table has this info', or 'tell me if the question is too vague'. It is essential for statements like 'What is the 3D structure of the gene?' (when the DB only has names) or 'Why does this gene cause cancer?' (when the DB stores relational facts, not explanations).

0
installs
▌
Speech To Text Translation · dingxingdi bundle
Use this skill when the user provides spoken audio (speech) and wants it translated into written text in a different language, especially when the audio is messy. Trigger it for requests like 'translate this voice clip with the background noise', 'what specifically did they say in Spanish despite the stuttering?', 'convert this speech audio to English text and ignore the static', or 'translate the speaker's words even if they keep repeating themselves.' It is essential for handling real-world acoustic challenges like crowded-room babble, ambient wind, hesitations, and self-corrections.

0
installs
▌
Comparative Response Ranking · dingxingdi bundle
Skill: comparative-response-ranking

0
installs
▌
Fine Grained Widget Grounding · dingxingdi bundle
Use this skill when the user wants to target tiny, crowded, or easy-to-misclick GUI elements, particularly in high-resolution (4K) professional software. Trigger it for requests like “click the small wrench icon,” “find the share button in this crowded toolbar,” “use the tiny checkboxes,” or “the target is like a needle in a haystack.” This skill is for GUI tasks where the agent must overcome extreme spatial dilution through multi-stage visual refinement and recover from initial localization errors using bidirectional search logic.

0
installs
▌
Temporal Sequential Reasoning · dingxingdi bundle
Use this skill when the user asks for 'the latest update', 'before or after', timeline sequences, finding optimal time windows, or requesting the earliest/latest feasible shift for an event. Trigger it for requests like 'find a rain-free window for my 2h trip', 'when is the latest I can leave early to avoid traffic?', 'is this API still current today?', 'was the iPad or AirTag launch first?', or 'what is the overarching trend from 2022 to 2024?'. This skill is essential for chronometric normalization, ordering evidence, and performing iterative search for time-slots that satisfy specific condition-duration constraints.

0
installs
▌
Multilingual Schema Grounding · dingxingdi bundle
Skill: multilingual schema grounding

0
installs
▌
Character Noise Translation · dingxingdi bundle
Use this skill when the user wants translation data for messy prompts with small spelling mistakes, broken typing, duplicated letters, swapped characters, or keyboard slips. Trigger it for plain-language requests such as "test whether it still translates when the ask has typos," "people type fast and miss letters," "make the prompt look slightly broken," or "check if the translator can survive misspellings without changing the task."

0
installs
▌
Precise Localized Editing · dingxingdi bundle
Use this skill when the user wants to apply a highly targeted edit—such as deleting redundant filler, rephrasing a paragraph without losing exact technical facts, or filling in a missing logical gap—without rewriting the whole document. Trigger it for requests like “delete this placeholder,” “cut the fluff from the second paragraph,” “rephrase this medical report but keep the exact measurements,” or “fill in the missing bridge between these two sections.”

0
installs
▌
Security Vulnerability Repair · dingxingdi bundle
Use this skill when the user wants software-fix data focused on identifying, mitigating, or preventing security bugs. Trigger it for requests like 'make security repair tasks', 'generate vulnerability-fixing data', 'ensure the new feature is secure against XSS/injections', or 'create patching tasks for insecure code'. This applies both to patching existing vulnerabilities and securely implementing missing features where the primary challenge is defending against CWEs (like timing side-channels, broken access control, or header injections) during development. Do not use it for ordinary non-security defects.

0
installs
▌
Evidence Localized Document QA · dingxingdi bundle
Use this skill when the user wants to locate exact evidence within a document to answer a question, particularly when the user's natural language phrasing differs significantly from the document's formal terminology (e.g., paraphrased queries). This skill helps the agent bridge the lexical gap between everyday questions and official documents like institutional norms, regulations, or scientific reports. Trigger it for requests like 'find the rule for X', 'summarize the eligibility criteria in this ordinance', 'where in the statute does it mention Y', or 'answer this based on the university regulations', especially when the user uses casual language to describe formal concepts.

0
installs
▌
Implicit Instruction Grounding · dingxingdi bundle
Use this skill when the user wants to test how an Agent handles instructions that are worded differently but mean the same thing (Instruction Unification) or when picking the right button out of many similar options in a single screen (Action Matching). Trigger it for requests like "make the button description vague," "use several different ways to ask for the same thing," "can the agent tell the 'Filter' icon from the 'Sort' icon?" or "test if it knows to pick a size before clicking Add to Cart." This skill ensures the agent maps natural language intents to the correct GUI widgets through semantic understanding, structural siblings, and topological dependencies rather than just matching words.

0
installs
▌
Safety Aware Action Governance · dingxingdi bundle
Use this skill to assess if an Agent's proposed actions are truly aligned with user intent rather than being hijacked by external tricks or internal errors. Trigger it for requests like “watch out for phishing links,” “make sure you don't delete the wrong file by mistake,” “is this action really what I asked for?”, “don't let the website trick you into doing something else,” or “check if this cleanup step is safe.” This skill ensures the agent validates every click against the user's authentic goal, refusing to follow malicious instructions in the environment (prompt injection) or perform harmful unintended actions (reasoning failures caused by ambiguous phrasing).

0
installs
▌
State Verified Task Completion · dingxingdi bundle
Use this skill when the user wants tasks that only count as solved if the underlying state really changed, not if the screen merely looks right for a moment. Trigger it for requests like “make sure it is actually saved,” “verify the result from the real app state,” “don’t trust a temporary popup,” or “judge success from the system record, not a screenshot alone.” This skill is for GUI tasks where durable completion must be grounded in application state, database state, filesystem state, or verified internal signals.

0
installs
▌
Temporal Gui Precision Control · dingxingdi bundle
Use this skill when the task requires actions to be timed perfectly, such as waiting for a hidden element to appear, holding a button for a specific duration, or clicking a target that is moving or changing. Trigger it for requests like "wait a few seconds before acting," "hold the button down," "be quick and tap it multiple times," "click it three times as it moves," or "patience is required to find the password."

0
installs
▌
Fuzzy Tool Retrieval · dingxingdi bundle
Skill: fuzzy-tool-retrieval

0
installs
▌
Full Text Literature Synthesis · dingxingdi bundle
Use this skill when the user wants questions that feel like paper-reading, literature review, recent findings, or 'you have to open the paper, not just the abstract'. Trigger it for requests like 'make it retrieve scientific papers', 'ask about a new result from the literature', 'force source-backed answering', or 'reward saying unsure when the paper isn't enough'. This skill is for bounded scientific corpora and full-text evidence use.

0
installs
▌
Automated Test Suite Synthesis · dingxingdi bundle
Use this skill when the user wants to generate high-quality, comprehensive test suites for a software problem or code snippet to ensure it is robust against edge cases and logical errors. It is triggered by natural language requests such as 'generate hard test cases', 'create an adversarial test suite for this algorithmic problem', 'find edge cases for my code', 'make sure my code handles extreme values', or 'build a verifier for this programming task'. It is specifically designed to proactively identify subtle logical flaws by analyzing problem constraints and comparing correct solutions against known error patterns.

0
installs
▌
Spatial Relation Reasoning · dingxingdi bundle
Skill: spatial-relation-reasoning

0
installs
▌
Cross App Workflow Coordination · dingxingdi bundle
Use this skill when the task involves moving data or state between different applications, or populating a form based on an external document. Trigger it for requests like 'remember the name from the previous screen,' 'help me apply for this job using my resume,' 'keep a note of that price for later,' or 'match the info from this file to the boxes in the app.' This skill is for GUI tasks requiring a chain of memory where information is extracted from one source (e.g., a PDF resume, a map result) and utilized in a distinct destination (e.g., a web application form, a messaging app).

0
installs
▌
Proverb Idiomatic Translation · dingxingdi bundle
Use this skill when the user wants translation data for culturally loaded text that cannot be translated literally, including cases where the source is written in informal phonetic scripts. Trigger it for requests like 'don't translate it word for word,' 'capture the slang and emoji vibe of this social media comment,' 'the text uses Romanized spelling for a local saying,' or 'use a native proverb equivalent.' It manages proverbs, internet slang, and cases where figurative meaning must be recovered from non-standardized orthography.

0
installs
▌
Task Progress Decision Making · dingxingdi bundle
Use this skill when the user asks 'what do I do next?', 'what was the step before this?', 'is it safe to perform this?', 'did they follow the manual?', 'how do I fix this mistake?', or 'score the performance/skill level of this operation'. Trigger it for tasks evaluating sequential procedures, forecasting upcoming actions, verifying adherence to external operational rules (like safety protocols or Critical View of Safety), or proposing optimizations to a completed process. It is also suitable for 'Expert-level' assessment where a set of professional criteria or rubrics must be applied to a long video trajectory to judge technical proficiency.

0
installs
▌
Long Horizon Web Task Execution · dingxingdi bundle
Use this skill when the user wants tasks that require a long sequence of actions across multiple screens, tracking state changes, executing recursive loops to generate exhaustive list data, tree-walking hidden menus, or filling out multi-page forms. Trigger it for requests like 'prowl this site to find hidden settings,' 'create a complete table by checking every item,' 'fill out the entire application using this document,' or 'apply all these filters while staying under budget.' It perfectly handles complex traversal loops, multi-item data aggregation across sub-pages, and mapping a site's hidden topology through persistent exploration.

0
installs
▌
Persistent Search Reformulation · dingxingdi bundle
Use this skill when the user wants questions where the answer requires the agent to try several search angles, recover from systemic web blocks, bypass paywalls/CAPTCHAs by seeking alternative sources, or rewrite queries heavily to beat dead ends. Trigger it for requests like “make it take a few searches,” “force recovery from 403 blocks,” “navigate around paywalls,” or “force the agent to keep refining the search constraints.” It is the definitive capability for testing persistence when the easiest path is either blocked by security guardrails or returns zero useful hits.

0
installs
▌
Narrative Novelty And Value · dingxingdi bundle
Use this skill when the user wants stories that feel fresh, clever, twisty, emotionally alive, structurally complex, or set in meticulously crafted speculative worlds. Trigger it for requests like 'make it more surprising,' 'add flashbacks to explain the past,' 'ensure the rules of the magic system are consistent over the 50-chapter novel,' or 'give me something with an earned twist.' It is specifically designed to produce open-ended creative quality where human preference rewards non-linear timelines, deep world-building integration, long-range narrative coherence, and subversion of generic AI sci-fi/fantasy tropes.

0
installs
▌
Structural Format Adherence · dingxingdi bundle
Use this skill when the writing must follow a very exact shape, outer format, or rigid template shell. Trigger it for requests like “make it two sections,” “give me exactly five bullet points,” “wrap everything in JSON,” “put a title in special brackets,” or “draft a formal agreement including these exact five clauses.” It is especially useful when the user cares about the architectural shell and structure of the document as much as the content.

0
installs
▌
Ml Data Curation And Refinement · dingxingdi bundle
Use this skill when the user wants to prepare, clean, or label datasets for machine learning using specialized code and automated models. Trigger it for requests like 'fill in the missing gaps in my data', 'automatically label this dataset based on our rules', 'impute the null values in my training set', or 'fix the data quality before training'. It is specifically designed for complex ML engineering tasks involving model-based imputation (like recovering sensor readings) and weak supervision pipelines (like heuristic-based labeling) rather than simple SQL data transformations.

0
installs
▌
Visual Front End Bug Resolution · dingxingdi bundle
Use this skill when the user wants front-end or visual bug-fix data where the question depends on screenshots, diagrams, UI appearance, layout, styling, or rendered interaction behavior. Trigger it for requests like 'give me UI bugs with images', 'make website fixes that need looking at the screenshot', 'generate front-end tasks with CSS or rendering issues', or 'create visual JavaScript bug-fix data'. Do not use it for purely backend repository issues, general software debugging without visual evidence, or security-only vulnerabilities.

0
installs
▌
Long Form Coherent Summarization · dingxingdi bundle
Use this skill when transforming massive documents or multi-source corpora into structured, coherent formats. Trigger for requests like 'summarize this huge PDF without losing the thread', 'draft a defense statement based on this complaint and the evidence list', 'create a presentation script from this report', or 'write the official trial facts by resolving contradictory testimonies into a ground-truth timeline'. This is critical when shifting text registers, interleaving visual anchors, or composing professional narrative sections from conflicting multi-source contexts.

0
installs
▌
Long Horizon Composite Execution · dingxingdi bundle
Use this skill when you have a big task that needs many steps to finish, like a long-term plan or a complex project. Trigger it for requests like “follow this long list of steps,” “help me reproduce this bug from the report,” “do a long sequence of chores across different screens,” or “figure out how to finish this multi-step task even if the instructions are messy.” It helps the agent group steps into clusters, look up help in manuals or wikis, and use expert shortcuts like commands to make sure the whole long plan works without getting lost.

0
installs
▌
Active Trace Oversight · dingxingdi bundle
Skill: active-trace-oversight

0
installs
▌
Bridge Based Multi Hop Reasoning · dingxingdi bundle
Use this skill when the user wants 'connect the dots' questions, hierarchical path-traversals, or questions about navigating a sequential process. Trigger it for natural-language requests like 'multi-hop questions', 'find a way to get to...', 'show me the steps to...', 'force the model to follow a shared thread across docs', or 'test if it can find the path even if some instructions are missing'. It targets structural traversal across documents, procedural manuals, or interface states.

0
installs
▌
Exhaustive Long Context Coverage · dingxingdi bundle
Use this skill when the user wants questions that require reading the entire context window, ensuring no file or nested branch is left behind. Trigger it for requests like 'need reading everything', 'give me a full breakdown of this specific chapter', 'summarize the statistics for all entities found', or 'tell me all the subsections' occurrences'. It forces extreme entity density and global context accounting across both multi-document spreads and deep intra-document hierarchies.

0
installs
▌
Noise Robust Evidence Extraction · dingxingdi bundle
Use this skill when the user wants questions where the right clue is present but surrounded by similar-looking junk, typographical errors, or misleading formatting. Trigger it for requests like 'mix in some confusing paragraphs', 'test whether it finds the wrong year', 'hide the answer among near misses', or 'test if the model can read through OCR errors like WN8A'. This skill ensures the agent can isolate the true semantic signal amidst both macro-level topical distractors and character-level document degradation.

0
installs
▌
Contextual Entity Disambiguation · dingxingdi bundle
Skill: contextual entity disambiguation

0
installs
▌
State Changing Data Manipulation · dingxingdi bundle
Use this skill when the user wants SQL data that goes beyond typical READs to encompass data modification loops like INSERT, UPDATE, or DELETE, as well as complex transactional logic for data lifecycles (merging records, setting TTL expirations, or updating locking flags). Trigger it for requests like “make examples that change the database”, “I want the model to delete stale records”, “consolidate these duplicate rows”, or “set an expiration deadline for the specified rows.”

0
installs

389 published skills · page 2 of 4