[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M74F4EPK4RCAFE24JSYTRWKJ":3,"skill-same:01M74F4EPK4RCAFE24JSYTRWKJ":52},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":14,"repositoryHtmlUrl":27,"repositoryHomepageUrl":6,"ownerHtmlUrl":28,"ownerBlogUrl":29,"ownerDescription":30,"updatedAt":31,"install":32,"resources":45},"01M74F4EPK4RCAFE24JSYTRWKJ","rust-error-handling",null,"Rust error-handling patterns and anti-patterns -- `unwrap()` in request hot paths, `panic!` instead of returning a `Result`, leaking error internals via `Debug` derive on error types containing privileged state. Patterns covered include `thiserror` for typed errors, `anyhow` for application-layer error propagation, and error-payload sanitization at API boundaries. Triggers on Rust error-prone code authoring (`unwrap`, `expect`, `panic!`, `Result\u003C_, _>` patterns). General security hygiene at the language-runtime layer.","MILTONADINA\u002FDevOPs","MILTONADINA","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F106546372?v=4","01M74F3R2PP4Z04DQMMBHSQAT1","Milton Adina","01M74F3R3CHTKPXJV4RP7RR3W8",0,"MIT","https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Fskills\u002Fstack-specific\u002Frust\u002Ferror-handling\u002FSKILL.md",[],[],"2026-11-11 15:11:14",false,"---\nname: rust-error-handling\ndescription: Rust error-handling patterns and anti-patterns -- `unwrap()` in request hot paths, `panic!` instead of returning a `Result`, leaking error internals via `Debug` derive on error types containing privileged state. Patterns covered include `thiserror` for typed errors, `anyhow` for application-layer error propagation, and error-payload sanitization at API boundaries. Triggers on Rust error-prone code authoring (`unwrap`, `expect`, `panic!`, `Result\u003C_, _>` patterns). General security hygiene at the language-runtime layer.\n---\n\n# Rust Error Handling\n\n> This skill addresses **general security hygiene at the\n> language-runtime layer** -- the patterns close common Rust failure\n> modes (request-handler panics, leaky error responses, internal-state\n> exposure via `Debug`) but they are NOT the load-bearing defense\n> against any specific OWASP ASI \u002F AST threat. The agent-specific\n> defenses operate at different layers: prompt-injection-defense for\n> ASI01\u002FASI04, Tool Misuse defenses (e.g., webhook idempotency) for\n> ASI02. Rust error handling is the substrate that lets the OTHER\n> defenses work without panicking the whole process.\n\n**Tradeoff:** `unwrap()` is shorter than proper `Result` handling.\nEach `unwrap` in a request path is a future production panic. The\ndiscipline below trades line-count for crash-resistance.\n\n---\n\n## Why this matters\n\nA Rust web service that panics on `unwrap()` fails the request. In a\n`tokio` runtime the panic unwinds only the task serving that request:\nthe runtime catches it and every other task keeps running, and the\nclient receives a 500 only if a layer such as tower-http's\n`CatchPanicLayer` converts the panic into a response. Built with\n`panic = \"abort\"`, the same panic terminates the whole process. The\ndownstream effects are: lost requests, unclear\nerror attribution in logs, and -- if the panic's payload contains\nprivileged state (a database connection string, a JWT, a customer\nemail) -- accidental disclosure when the panic is logged.\n\nThe mitigation is structural: convert `unwrap()` \u002F `panic!` paths to\n`Result` returns that the caller can handle deliberately, derive\n`Debug` carefully on error types that may carry sensitive payloads,\nand sanitize the error response at the API boundary.\n\n---\n\n## Pattern 1 -- Typed errors with `thiserror`\n\nDefine one error enum per crate (or per logical module) using\n`thiserror`. The enum variants name the failure modes the code can\nencounter; their `Display` impls produce log-safe messages.\n\n```rust\nuse thiserror::Error;\n\n#[derive(Debug, Error)]\npub enum CheckoutError {\n    #[error(\"payment provider rejected the charge\")]\n    PaymentRejected,\n\n    #[error(\"order {order_id} not found\")]\n    OrderNotFound { order_id: String },\n\n    #[error(\"database error\")]\n    Database(#[from] sqlx::Error),\n\n    #[error(\"internal: {0}\")]\n    Internal(String),\n}\n```\n\nEach handler returns `Result\u003CT, CheckoutError>` and uses `?` for\npropagation. The caller (API handler, CLI command) maps the typed\nerror to an HTTP status \u002F exit code in one place.\n\n```rust\npub async fn checkout(order_id: String) -> Result\u003CReceipt, CheckoutError> {\n    let order = db::find_order(&order_id).await?;  \u002F\u002F ? propagates Database errors\n    let order = order.ok_or(CheckoutError::OrderNotFound { order_id })?;\n    let receipt = payment::charge(&order).await\n        .map_err(|_| CheckoutError::PaymentRejected)?;\n    Ok(receipt)\n}\n```\n\nThis pattern keeps the happy path readable AND maintains structured\nerror categories for downstream handling.\n\n---\n\n## Pattern 2 -- `anyhow` for application-layer error propagation\n\nFor binary crates (CLIs, services) where typed errors would add ceremony\nwithout value, use `anyhow::Result\u003CT>`. It wraps any error type and\nprovides `.context(...)` for adding human-readable trace info.\n\n```rust\nuse anyhow::{Context, Result};\n\npub async fn run(args: Args) -> Result\u003C()> {\n    let config = load_config(&args.config_path)\n        .with_context(|| format!(\"failed to load config from {}\", args.config_path))?;\n\n    let pool = db::connect(&config.database_url).await\n        .context(\"failed to connect to database\")?;\n\n    for migration in args.migrations {\n        apply(&pool, migration).await\n            .with_context(|| format!(\"migration {migration} failed\"))?;\n    }\n\n    Ok(())\n}\n```\n\nThe `.context(...)` calls build a stack of trace messages. When an\nerror finally bubbles to `main()`, printing it produces a multi-line\ntrace that points at the operation, not just the leaf cause. This is\nthe closest Rust gets to Python tracebacks for application code.\n\n`anyhow` is for application crates. Library crates should prefer\n`thiserror` so consumers can pattern-match specific error variants.\n\n---\n\n## Pattern 3 -- Sanitize error payloads at the API boundary\n\nInternal error types (typed with `thiserror`, traced with `anyhow`)\noften contain implementation-specific detail: SQL state codes,\nfile system paths, third-party API responses. These should NOT\nappear in HTTP responses to external clients.\n\n```rust\nuse axum::response::{IntoResponse, Response};\nuse axum::http::StatusCode;\n\nimpl IntoResponse for CheckoutError {\n    fn into_response(self) -> Response {\n        \u002F\u002F Log the FULL error for ourselves (server-side, audited).\n        tracing::error!(\"checkout failed: {:?}\", self);\n\n        \u002F\u002F Return a SANITIZED message to the client.\n        let (status, message) = match self {\n            CheckoutError::PaymentRejected => (StatusCode::PAYMENT_REQUIRED, \"payment rejected\"),\n            CheckoutError::OrderNotFound { .. } => (StatusCode::NOT_FOUND, \"order not found\"),\n            CheckoutError::Database(_) | CheckoutError::Internal(_) => {\n                (StatusCode::INTERNAL_SERVER_ERROR, \"internal server error\")\n            },\n        };\n        (status, message).into_response()\n    }\n}\n```\n\nThe server logs carry full detail for debugging; the client sees a\nshort message that doesn't leak the database schema, the payment\nprovider's specific error code, or any other internal state. This is\nthe load-bearing boundary control.\n\n---\n\n## Anti-patterns\n\n### Anti-pattern 1 -- `unwrap()` in request hot paths\n\n```rust\n\u002F\u002F WRONG\nasync fn get_user(Path(user_id): Path\u003CString>) -> Json\u003CUser> {\n    let user = db::find_user(&user_id).await.unwrap();  \u002F\u002F PANIC on db error\n    Json(user.unwrap())  \u002F\u002F PANIC on user-not-found\n}\n```\n\nTwo panics per request, both triggered by ordinary conditions\n(database down, user doesn't exist). The request fails with no\nuseful information, the panic message gets logged (potentially\nrevealing internal state), and under load these add up to a flaky\nservice. Convert to `Result` propagation; let the framework's error\nhandling produce sanitized responses.\n\n`unwrap()` and `expect()` are acceptable in:\n- Tests (panic = test fail, which is the intent)\n- Constants \u002F `const fn` contexts\n- Genuinely unreachable cases where the panic would indicate a\n  programming bug, not a runtime condition (annotate the rationale\n  with a comment)\n\nThey are NOT acceptable in handler bodies, library APIs, or any path\nthat runs against attacker-controlled inputs.\n\n### Anti-pattern 2 -- `panic!()` instead of returning a `Result`\n\n```rust\n\u002F\u002F WRONG\nfn parse_config(text: &str) -> Config {\n    let parsed: Config = serde_json::from_str(text)\n        .unwrap_or_else(|e| panic!(\"config parse failed: {}\", e));\n    parsed\n}\n```\n\nThe function signature lies: it claims to return `Config`, but really\nreturns `Config` OR panics. A caller that wraps it in error-handling\ngets nothing because the panic skips over all error-handling layers.\nChange the signature to `Result\u003CConfig, ConfigError>` and let the\ncaller decide how to react.\n\n### Anti-pattern 3 -- Leaking internal state through `Debug` derive\n\n```rust\n\u002F\u002F WRONG\n#[derive(Debug)]\npub struct ApiError {\n    pub status_code: u16,\n    pub message: String,\n    pub db_connection_string: String,  \u002F\u002F leaks!\n    pub jwt_signing_secret: String,    \u002F\u002F leaks!\n}\n```\n\nIf `ApiError` is ever logged with `tracing::error!(\"{:?}\", err)` or\nserialized into a panic message, the privileged fields leak into log\nstorage. Either (a) don't store sensitive data on the error type --\nthey can stay in the production runtime's secrets store -- or (b)\nmanually implement `Debug` to redact:\n\n```rust\nimpl std::fmt::Debug for ApiError {\n    fn fmt(&self, f: &mut std::fmt::Formatter\u003C'_>) -> std::fmt::Result {\n        f.debug_struct(\"ApiError\")\n            .field(\"status_code\", &self.status_code)\n            .field(\"message\", &self.message)\n            .field(\"db_connection_string\", &\"[REDACTED]\")\n            .field(\"jwt_signing_secret\", &\"[REDACTED]\")\n            .finish()\n    }\n}\n```\n\nThe same discipline applies to types embedded inside error variants\n(a `sqlx::Error::Database` may carry the failed SQL statement, which\nmay itself contain user-controlled inputs that shouldn't be logged\nverbatim).\n\n---\n\n## ASI\u002FAST mapping\n\n**No canonical ASI\u002FAST applies** -- Rust error handling is general\nsecurity hygiene at the language-runtime layer; the failure modes\n(panics, leaky errors, internal-state exposure) are not agent-specific\nthreat categories from `governance\u002Fowasp-asi-2026\u002Fthreats.md`. Cross-\nreferences to skills that DO address agent-specific surfaces:\n\n- `skills\u002Funiversal\u002Fsecurity\u002Fprompt-injection-defense\u002FSKILL.md` --\n  ASI01 + ASI04 for content-level attacks\n- `skills\u002Funiversal\u002Fsecurity\u002Fwebhook-idempotency\u002FSKILL.md` -- ASI02\n  for control-flow replay attacks\n- `skills\u002Fstack-specific\u002Frust\u002Fcargo-audit\u002FSKILL.md` -- AST08 for the\n  dependency-update tampering surface (the supply-chain side of Rust)\n\nThe complementary `cargo-audit` skill covers the side of Rust hygiene\nthat DOES have a canonical AST mapping. Together the two Rust skills\nspan the language-substrate concerns for which agentic systems benefit\nfrom explicit guidance.\n\n---\n\n## When this skill is working\n\n- `grep -rn \"unwrap()\" src\u002F` returns only test files (or annotated\n  exceptions with rationale comments).\n- Service `tracing::error!` logs never contain database connection\n  strings, JWT secrets, or other secrets-class fields -- verified via\n  log-redaction unit tests.\n- Production 500-response messages are short, generic, and don't leak\n  internal state -- verified via integration tests.\n\n---\n\n## See also\n\n- The `thiserror` crate: https:\u002F\u002Fdocs.rs\u002Fthiserror\u002F\n- The `anyhow` crate: https:\u002F\u002Fdocs.rs\u002Fanyhow\u002F\n- `skills\u002Fstack-specific\u002Frust\u002Fcargo-audit\u002FSKILL.md` -- supply-chain\n  companion (AST08)\n","# Rust Error Handling\n\n> This skill addresses **general security hygiene at the\n> language-runtime layer** -- the patterns close common Rust failure\n> modes (request-handler panics, leaky error responses, internal-state\n> exposure via `Debug`) but they are NOT the load-bearing defense\n> against any specific OWASP ASI \u002F AST threat. The agent-specific\n> defenses operate at different layers: prompt-injection-defense for\n> ASI01\u002FASI04, Tool Misuse defenses (e.g., webhook idempotency) for\n> ASI02. Rust error handling is the substrate that lets the OTHER\n> defenses work without panicking the whole process.\n\n**Tradeoff:** `unwrap()` is shorter than proper `Result` handling.\nEach `unwrap` in a request path is a future production panic. The\ndiscipline below trades line-count for crash-resistance.\n\n---\n\n## Why this matters\n\nA Rust web service that panics on `unwrap()` fails the request. In a\n`tokio` runtime the panic unwinds only the task serving that request:\nthe runtime catches it and every other task keeps running, and the\nclient receives a 500 only if a layer such as tower-http's\n`CatchPanicLayer` converts the panic into a response. Built with\n`panic = \"abort\"`, the same panic terminates the whole process. The\ndownstream effects are: lost requests, unclear\nerror attribution in logs, and -- if the panic's payload contains\nprivileged state (a database connection string, a JWT, a customer\nemail) -- accidental disclosure when the panic is logged.\n\nThe mitigation is structural: convert `unwrap()` \u002F `panic!` paths to\n`Result` returns that the caller can handle deliberately, derive\n`Debug` carefully on error types that may carry sensitive payloads,\nand sanitize the error response at the API boundary.\n\n---\n\n## Pattern 1 -- Typed errors with `thiserror`\n\nDefine one error enum per crate (or per logical module) using\n`thiserror`. The enum variants name the failure modes the code can\nencounter; their `Display` impls produce log-safe messages.\n\n```rust\nuse thiserror::Error;\n\n#[derive(Debug, Error)]\npub enum CheckoutError {\n    #[error(\"payment provider rejected the charge\")]\n    PaymentRejected,\n\n    #[error(\"order {order_id} not found\")]\n    OrderNotFound { order_id: String },\n\n    #[error(\"database error\")]\n    Database(#[from] sqlx::Error),\n\n    #[error(\"internal: {0}\")]\n    Internal(String),\n}\n```\n\nEach handler returns `Result\u003CT, CheckoutError>` and uses `?` for\npropagation. The caller (API handler, CLI command) maps the typed\nerror to an HTTP status \u002F exit code in one place.\n\n```rust\npub async fn checkout(order_id: String) -> Result\u003CReceipt, CheckoutError> {\n    let order = db::find_order(&order_id).await?;  \u002F\u002F ? propagates Database errors\n    let order = order.ok_or(CheckoutError::OrderNotFound { order_id })?;\n    let receipt = payment::charge(&order).await\n        .map_err(|_| CheckoutError::PaymentRejected)?;\n    Ok(receipt)\n}\n```\n\nThis pattern keeps the happy path readable AND maintains structured\nerror categories for downstream handling.\n\n---\n\n## Pattern 2 -- `anyhow` for application-layer error propagation\n\nFor binary crates (CLIs, services) where typed errors would add ceremony\nwithout value, use `anyhow::Result\u003CT>`. It wraps any error type and\nprovides `.context(...)` for adding human-readable trace info.\n\n```rust\nuse anyhow::{Context, Result};\n\npub async fn run(args: Args) -> Result\u003C()> {\n    let config = load_config(&args.config_path)\n        .with_context(|| format!(\"failed to load config from {}\", args.config_path))?;\n\n    let pool = db::connect(&config.database_url).await\n        .context(\"failed to connect to database\")?;\n\n    for migration in args.migrations {\n        apply(&pool, migration).await\n            .with_context(|| format!(\"migration {migration} failed\"))?;\n    }\n\n    Ok(())\n}\n```\n\nThe `.context(...)` calls build a stack of trace messages. When an\nerror finally bubbles to `main()`, printing it produces a multi-line\ntrace that points at the operation, not just the leaf cause. This is\nthe closest Rust gets to Python tracebacks for application code.\n\n`anyhow` is for application crates. Library crates should prefer\n`thiserror` so consumers can pattern-match specific error variants.\n\n---\n\n## Pattern 3 -- Sanitize error payloads at the API boundary\n\nInternal error types (typed with `thiserror`, traced with `anyhow`)\noften contain implementation-specific detail: SQL state codes,\nfile system paths, third-party API responses. These should NOT\nappear in HTTP responses to external clients.\n\n```rust\nuse axum::response::{IntoResponse, Response};\nuse axum::http::StatusCode;\n\nimpl IntoResponse for CheckoutError {\n    fn into_response(self) -> Response {\n        \u002F\u002F Log the FULL error for ourselves (server-side, audited).\n        tracing::error!(\"checkout failed: {:?}\", self);\n\n        \u002F\u002F Return a SANITIZED message to the client.\n        let (status, message) = match self {\n            CheckoutError::PaymentRejected => (StatusCode::PAYMENT_REQUIRED, \"payment rejected\"),\n            CheckoutError::OrderNotFound { .. } => (StatusCode::NOT_FOUND, \"order not found\"),\n            CheckoutError::Database(_) | CheckoutError::Internal(_) => {\n                (StatusCode::INTERNAL_SERVER_ERROR, \"internal server error\")\n            },\n        };\n        (status, message).into_response()\n    }\n}\n```\n\nThe server logs carry full detail for debugging; the client sees a\nshort message that doesn't leak the database schema, the payment\nprovider's specific error code, or any other internal state. This is\nthe load-bearing boundary control.\n\n---\n\n## Anti-patterns\n\n### Anti-pattern 1 -- `unwrap()` in request hot paths\n\n```rust\n\u002F\u002F WRONG\nasync fn get_user(Path(user_id): Path\u003CString>) -> Json\u003CUser> {\n    let user = db::find_user(&user_id).await.unwrap();  \u002F\u002F PANIC on db error\n    Json(user.unwrap())  \u002F\u002F PANIC on user-not-found\n}\n```\n\nTwo panics per request, both triggered by ordinary conditions\n(database down, user doesn't exist). The request fails with no\nuseful information, the panic message gets logged (potentially\nrevealing internal state), and under load these add up to a flaky\nservice. Convert to `Result` propagation; let the framework's error\nhandling produce sanitized responses.\n\n`unwrap()` and `expect()` are acceptable in:\n- Tests (panic = test fail, which is the intent)\n- Constants \u002F `const fn` contexts\n- Genuinely unreachable cases where the panic would indicate a\n  programming bug, not a runtime condition (annotate the rationale\n  with a comment)\n\nThey are NOT acceptable in handler bodies, library APIs, or any path\nthat runs against attacker-controlled inputs.\n\n### Anti-pattern 2 -- `panic!()` instead of returning a `Result`\n\n```rust\n\u002F\u002F WRONG\nfn parse_config(text: &str) -> Config {\n    let parsed: Config = serde_json::from_str(text)\n        .unwrap_or_else(|e| panic!(\"config parse failed: {}\", e));\n    parsed\n}\n```\n\nThe function signature lies: it claims to return `Config`, but really\nreturns `Config` OR panics. A caller that wraps it in error-handling\ngets nothing because the panic skips over all error-handling layers.\nChange the signature to `Result\u003CConfig, ConfigError>` and let the\ncaller decide how to react.\n\n### Anti-pattern 3 -- Leaking internal state through `Debug` derive\n\n```rust\n\u002F\u002F WRONG\n#[derive(Debug)]\npub struct ApiError {\n    pub status_code: u16,\n    pub message: String,\n    pub db_connection_string: String,  \u002F\u002F leaks!\n    pub jwt_signing_secret: String,    \u002F\u002F leaks!\n}\n```\n\nIf `ApiError` is ever logged with `tracing::error!(\"{:?}\", err)` or\nserialized into a panic message, the privileged fields leak into log\nstorage. Either (a) don't store sensitive data on the error type --\nthey can stay in the production runtime's secrets store -- or (b)\nmanually implement `Debug` to redact:\n\n```rust\nimpl std::fmt::Debug for ApiError {\n    fn fmt(&self, f: &mut std::fmt::Formatter\u003C'_>) -> std::fmt::Result {\n        f.debug_struct(\"ApiError\")\n            .field(\"status_code\", &self.status_code)\n            .field(\"message\", &self.message)\n            .field(\"db_connection_string\", &\"[REDACTED]\")\n            .field(\"jwt_signing_secret\", &\"[REDACTED]\")\n            .finish()\n    }\n}\n```\n\nThe same discipline applies to types embedded inside error variants\n(a `sqlx::Error::Database` may carry the failed SQL statement, which\nmay itself contain user-controlled inputs that shouldn't be logged\nverbatim).\n\n---\n\n## ASI\u002FAST mapping\n\n**No canonical ASI\u002FAST applies** -- Rust error handling is general\nsecurity hygiene at the language-runtime layer; the failure modes\n(panics, leaky errors, internal-state exposure) are not agent-specific\nthreat categories from `governance\u002Fowasp-asi-2026\u002Fthreats.md`. Cross-\nreferences to skills that DO address agent-specific surfaces:\n\n- `skills\u002Funiversal\u002Fsecurity\u002Fprompt-injection-defense\u002FSKILL.md` --\n  ASI01 + ASI04 for content-level attacks\n- `skills\u002Funiversal\u002Fsecurity\u002Fwebhook-idempotency\u002FSKILL.md` -- ASI02\n  for control-flow replay attacks\n- `skills\u002Fstack-specific\u002Frust\u002Fcargo-audit\u002FSKILL.md` -- AST08 for the\n  dependency-update tampering surface (the supply-chain side of Rust)\n\nThe complementary `cargo-audit` skill covers the side of Rust hygiene\nthat DOES have a canonical AST mapping. Together the two Rust skills\nspan the language-substrate concerns for which agentic systems benefit\nfrom explicit guidance.\n\n---\n\n## When this skill is working\n\n- `grep -rn \"unwrap()\" src\u002F` returns only test files (or annotated\n  exceptions with rationale comments).\n- Service `tracing::error!` logs never contain database connection\n  strings, JWT secrets, or other secrets-class fields -- verified via\n  log-redaction unit tests.\n- Production 500-response messages are short, generic, and don't leak\n  internal state -- verified via integration tests.\n\n---\n\n## See also\n\n- The `thiserror` crate: https:\u002F\u002Fdocs.rs\u002Fthiserror\u002F\n- The `anyhow` crate: https:\u002F\u002Fdocs.rs\u002Fanyhow\u002F\n- `skills\u002Fstack-specific\u002Frust\u002Fcargo-audit\u002FSKILL.md` -- supply-chain\n  companion (AST08)\n",{"name":5,"description":7},"main","5a590e92c8f62b54c96a6928215ac2145b671e03","skills\u002Fstack-specific\u002Frust\u002Ferror-handling","https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs","https:\u002F\u002Fgithub.com\u002FMILTONADINA","https:\u002F\u002Fwww.linkedin.com\u002Fin\u002Fmiltonadina","CS\u002FCybersecurity SWE & former Epidemiologist. Building secure, test-driven full-stack & mobile apps (TS\u002FReact\u002FNode, Java\u002FSpring, Flutter).","2026-11-14 20:03:36",{"source":8,"skillName":5,"commands":33,"prompt":43,"zipAvailable":44},[34,37,40],{"tool":35,"command":36},"npx","npx skills add MILTONADINA\u002FDevOPs --skill rust-error-handling",{"tool":38,"command":39},"bunx","bunx skills add MILTONADINA\u002FDevOPs --skill rust-error-handling",{"tool":41,"command":42},"pnpm","pnpm dlx skills add MILTONADINA\u002FDevOPs --skill rust-error-handling","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Fskills\u002Fstack-specific\u002Frust\u002Ferror-handling\u002FSKILL.md",true,[46],{"path":47,"resourceType":48,"resourceTypeDesc":49,"sizeBytes":50,"sourceHtmlUrl":51},"SKILL.md.bundle","OTHER","其他",9515,"https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Fskills\u002Fstack-specific\u002Frust\u002Ferror-handling\u002FSKILL.md.bundle",[53,60,67,74,79,86],{"skillNo":54,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":57,"categories":58,"keywords":59,"publishedAt":19},"01M74F7F3HN6J7CSFHBVQAE9S5","karpathy-guidelines","Behavioral guidelines that reduce common LLM coding mistakes. Apply whenever writing, modifying, or reviewing code. Don't assume requirements, don't overcomplicate, don't refactor unrelated code, and define success criteria before implementing. Use this skill on every non-trivial coding task to avoid bloat, silent assumptions, and completion-bias.","https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Ftests\u002Ffixtures\u002Fsecurity\u002Fmodified-skill\u002FSKILL.md",[],[],{"skillNo":61,"name":62,"nameZh":6,"description":63,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":19},"01M74F7D60N9FRWWWHCGZMMB41","unsigned-missing-sig-fixture","Test fixture (F.09) — SKILL.md without an accompanying .sig file. Default install rejects with exit 2; --allow-unsigned --rationale=\"...\" proceeds.","https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Ftests\u002Ffixtures\u002Finstall\u002Fsource-skills\u002Funsigned-missing-sig\u002FSKILL.md",[],[],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":73,"publishedAt":19},"01M74F7BKGX67Q606QPKZV7TQV","unsigned-mismatched-sig-fixture","Test fixture (F.09) — SKILL.md whose accompanying .sig signs different content. NFR-F3 hash check catches this even with --allow-unsigned.","https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Ftests\u002Ffixtures\u002Finstall\u002Fsource-skills\u002Funsigned-mismatched-sig\u002FSKILL.md",[],[],{"skillNo":75,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M74F793BYMX98EQC5XP4CDZK","https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Ftests\u002Ffixtures\u002Finstall\u002Fsource-skills\u002Fsigned\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M74F7481EBD7G5471ZC4S9YB","webhook-idempotency","Defend against double-processing of webhook events across every provider (Stripe, GitHub, Slack, Twilio, SendGrid). Idempotency-key pattern + replay-window enforcement + dedupe-storage strategy. Triggers on any webhook handler authoring (route matching \u002Fwebhook(s)?\u002F, Stripe-Signature \u002F X-Hub-Signature-256 header references). Defense against OWASP ASI02 (Tool Misuse) -- a replayed webhook that re-triggers a destructive tool is the canonical control-flow-level replay attack. Universal across providers; stack-specific signature verification lives in stack-specific skills.","https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Fskills\u002Funiversal\u002Fsecurity\u002Fwebhook-idempotency\u002FSKILL.md",[],[],{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":19},"01M74F71Q6JKRFJ66G5T98KE8H","semgrep-scan","Run Semgrep static analysis to detect insecure code patterns - SQL injection, XSS, path traversal, weak crypto, broken auth, OWASP Top 10 issues. Use on every file change touching security-sensitive code and as part of the tiered security gate. Complements gitleaks (which catches secrets) by catching insecure logic.","https:\u002F\u002Fgithub.com\u002FMILTONADINA\u002FDevOPs\u002Fblob\u002Fmain\u002Fskills\u002Funiversal\u002Fsecurity\u002Fsemgrep-scan\u002FSKILL.md",[],[]]