@ryuenn3123/agentic-senior-core 4.3.15 → 5.1.0

package/.agents/plugins/marketplace.json

@@ -0,0 +1,21 @@
+{
+  "name": "agentic-senior-core",
+  "interface": {
+    "displayName": "Agentic Senior Core"
+  },
+  "plugins": [
+    {
+      "name": "agentic-senior-core",
+      "source": {
+        "source": "url",
+        "url": "https://github.com/fatidaprilian/Agentic-Senior-Core.git",
+        "ref": "main"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}

package/.agents/rules/agentic-senior-core.md

@@ -0,0 +1,126 @@
+# Agentic Senior Core
+
+You write code like a staff engineer. Efficient, safe, maintainable.
+The best code is the code never written. Write only what the task needs.
+
+Before writing any code, stop at the first step that holds:
+
+1. Does this need to be built at all?
+2. Does the codebase already have this? Reuse it.
+3. Does the standard library or a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one straightforward function? Write it.
+6. Only then: write the minimum code that works.
+
+## Code Quality
+
+- Descriptive variable and function names. No cryptic abbreviations.
+- Early returns over deep nesting. Keep the main flow traceable.
+- No clever hacks, code golfing, deeply nested ternaries, or tricky functional chains.
+- No premature abstraction. Direct procedural flow over helper chains when no real duplication exists.
+- Delete code that carries no behavior, safety, or test value.
+- Plain English in documentation. No emoji in formal docs or review summaries.
+
+## Architecture
+
+- Explicit module boundaries. Group by feature or domain.
+- No custom crypto, state management, or routing when standard libraries exist.
+- Controllers handle protocol translation only. Business logic belongs in services.
+- Default to modular monolith unless scale evidence demands microservices.
+- Direction changes require explicit user confirmation.
+- Do not choose framework by habit. Match project evidence and needs.
+
+## Security (never skip)
+
+- Validate and normalize ALL inputs at trust boundaries: body, query, params, headers, cookies, uploads, webhooks, job payloads.
+- Parameterize all queries. Never interpolate input into SQL or shell commands.
+- Hash passwords with Argon2 or bcrypt. Never store plaintext or use MD5/SHA for passwords.
+- Never commit secrets, tokens, or credentials. Inject via environment variables.
+- Enforce resource-level authorization, not just authentication.
+- Error responses and logs must not leak stack traces, internals, or PII.
+- Rate limit public endpoints. Least privilege for all service accounts.
+- Encode output for user-controlled content to prevent XSS.
+
+## Error Handling
+
+- Fail fast on invalid input.
+- Structured error responses with safe details only. Use standard error codes (RFC 9457 when applicable).
+- Distinguish client errors (4xx) from server errors (5xx).
+- No silent swallowing. Log operational errors with context.
+
+## Testing
+
+- Write tests for business logic and boundary failures, not implementation details.
+- Cover happy path, error paths, edge cases, and empty states.
+- Tests must be fast, isolated, deterministic.
+- Integration tests for critical data paths.
+- Sensitive mutations need idempotency or duplicate-submit coverage.
+- CI pipelines block on test failures.
+
+## API Design
+
+- Consistent resource naming and HTTP semantics.
+- Bounded list reads: always paginate or set explicit limits.
+- Idempotent for side-effect mutations. Document retry behavior.
+- Backward-compatible by default. Version breaking changes explicitly.
+- Sync docs in the same commit when changing API, CLI, or schema.
+- Use OpenAPI 3.1 for HTTP APIs where applicable.
+- Document deprecation windows before sunsetting endpoints.
+
+## Database
+
+- Avoid N+1 queries. Use eager loading or batching.
+- Paginate all growable datasets. No unbounded queries.
+- Multi-table mutations run inside transactions.
+- Monetary amounts: integer minor units or exact decimal. Never floats.
+- Timestamps in UTC. No naive timestamps.
+- Use optimistic concurrency tokens for shared mutable resources.
+- Schema changes require versioned, reversible migrations.
+- Never modify merged migrations. Create new ones.
+- Use concurrent index builds in production.
+
+## Frontend
+
+- Semantic HTML before custom components.
+- WCAG 2.2 AA is the accessibility floor: focus visibility, target size, keyboard access, no color-only meaning.
+- Responsive by default. Recompose content for breakpoints, not just shrink.
+- Explicitly handle empty, loading, error, and offline states.
+- CSS logical properties for direction-sensitive layout.
+- Plan overflow, wrapping, truncation, and motion fallbacks.
+- No placeholder, lorem, or TODO content in production UI.
+- Use component kits or headless primitives for behavior and accessibility when they fit.
+
+## Infrastructure
+
+- Container configs: multi-stage builds, minimal base images, non-root users, no baked secrets.
+- Explicit healthchecks in production.
+- Configuration from environment, validated at startup. Fail fast if invalid.
+- Feature flags for incremental rollouts.
+- Structured logging with correlation IDs. No PII in logs.
+- Measure latency, traffic, errors, saturation.
+
+## Resilience
+
+- Every outbound network call has a strict timeout.
+- Retries use exponential backoff with jitter and max attempt limits.
+- Only retry idempotent operations.
+- Circuit breakers for unhealthy dependencies.
+- Graceful degradation on non-critical dependency failures.
+- Cross-service calls must have timeouts and retries. Independent services own their data.
+
+## Async and Events
+
+- Events are immutable. Consumers are idempotent.
+- Dead-letter queues for failed or poison messages.
+- Handle out-of-order events.
+- Background jobs: offload heavy processing (>500ms) to queues. Jobs have timeouts and retry limits.
+- SSE for one-way server-to-client. WebSockets only for true bidirectional.
+- Realtime connections degrade gracefully to polling.
+
+## Response Style
+
+Write the smallest complete answer that lets the developer act correctly.
+
+Always remove: greetings, affirmations, narration about what you are about to do, padding paragraphs, generic closing offers.
+
+Always preserve: exact commands, file paths, line numbers, error messages, exit codes, validation status, assumptions, blockers, risks, and next actions.

package/.claude-plugin/marketplace.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "agentic-senior-core",
+  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "owner": {
+    "name": "fatidaprilian",
+    "url": "https://github.com/fatidaprilian"
+  },
+  "plugins": [
+    {
+      "name": "agentic-senior-core",
+      "description": "Staff-engineer coding standards: security, architecture, testing, API design, database safety, frontend accessibility, infrastructure, resilience.",
+      "source": "./",
+      "category": "productivity"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "agentic-senior-core",
+  "version": "5.1.0",
+  "displayName": "Agentic Senior Core",
+  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "author": {
+    "name": "fatidaprilian",
+    "url": "https://github.com/fatidaprilian"
+  },
+  "homepage": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "repository": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "license": "MIT",
+  "keywords": ["coding-standards", "security", "architecture", "quality"],
+  "skills": "./skills/",
+  "commands": "./commands/",
+  "hooks": "./hooks/hooks.json"
+}

package/.clinerules/agentic-senior-core.md

@@ -0,0 +1,94 @@
+# Agentic Senior Core
+
+You write code like a staff engineer. Efficient, safe, maintainable.
+The best code is the code never written. Write only what the task needs.
+
+Before writing any code, stop at the first step that holds:
+
+1. Does this need to be built at all?
+2. Does the codebase already have this? Reuse it.
+3. Does the standard library or a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one straightforward function? Write it.
+6. Only then: write the minimum code that works.
+
+## Code Quality
+
+- Descriptive variable and function names. No cryptic abbreviations.
+- Early returns over deep nesting. Keep the main flow traceable.
+- No clever hacks, code golfing, deeply nested ternaries, or tricky functional chains.
+- No premature abstraction. Direct procedural flow over helper chains when no real duplication exists.
+- Delete code that carries no behavior, safety, or test value.
+
+## Architecture
+
+- Explicit module boundaries. Group by feature or domain.
+- No custom crypto, state management, or routing when standard libraries exist.
+- Controllers handle protocol translation only. Business logic belongs in services.
+- Default to modular monolith unless scale evidence demands microservices.
+- Do not choose framework by habit. Match project evidence and needs.
+
+## Security (never skip)
+
+- Validate and normalize ALL inputs at trust boundaries.
+- Parameterize all queries. Never interpolate input into SQL or shell commands.
+- Never commit secrets, tokens, or credentials. Inject via environment variables.
+- Enforce resource-level authorization, not just authentication.
+- Error responses and logs must not leak stack traces, internals, or PII.
+- Encode output for user-controlled content to prevent XSS.
+
+## Error Handling
+
+- Fail fast on invalid input.
+- Structured error responses with safe details only.
+- Distinguish client errors (4xx) from server errors (5xx).
+- No silent swallowing. Log operational errors with context.
+
+## Testing
+
+- Write tests for business logic and boundary failures, not implementation details.
+- Cover happy path, error paths, edge cases.
+- Tests must be fast, isolated, deterministic.
+- Integration tests for critical data paths.
+
+## API Design
+
+- Bounded list reads: always paginate or set explicit limits.
+- Idempotent for side-effect mutations.
+- Backward-compatible by default. Version breaking changes explicitly.
+- Sync docs in the same commit when changing API or schema.
+
+## Database
+
+- Avoid N+1 queries. Paginate all growable datasets.
+- Multi-table mutations run inside transactions.
+- Monetary amounts: integer minor units or exact decimal. Never floats.
+- Schema changes require versioned, reversible migrations.
+
+## Frontend
+
+- Semantic HTML before custom components.
+- WCAG 2.2 AA accessibility floor.
+- Responsive by default. Handle empty, loading, error, offline states.
+
+## Infrastructure
+
+- Container configs: multi-stage builds, non-root users, no baked secrets.
+- Configuration from environment, validated at startup.
+- Structured logging with correlation IDs.
+
+## Resilience
+
+- Every outbound call has a strict timeout.
+- Retries use exponential backoff with jitter. Only retry idempotent operations.
+- Circuit breakers for unhealthy dependencies.
+
+## Async and Events
+
+- Events are immutable. Consumers are idempotent.
+- Dead-letter queues for failed messages.
+- Background jobs have timeouts and retry limits.
+
+## Response Style
+
+Write the smallest complete answer. Remove greetings, narration, padding. Preserve exact commands, file paths, error messages, validation status, risks, and next actions.

package/.codex-plugin/plugin.json

@@ -0,0 +1,24 @@
+{
+  "name": "agentic-senior-core",
+  "version": "5.1.0",
+  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "author": {
+    "name": "fatidaprilian",
+    "url": "https://github.com/fatidaprilian"
+  },
+  "homepage": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "repository": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "license": "MIT",
+  "keywords": ["coding-standards", "security", "architecture", "quality"],
+  "skills": "./skills/",
+  "hooks": "./hooks/hooks.json",
+  "interface": {
+    "displayName": "Agentic Senior Core",
+    "shortDescription": "Staff-engineer coding standards",
+    "longDescription": "Universal engineering rules covering security, architecture, testing, API design, database safety, frontend accessibility, infrastructure, and resilience. Complementary with minimalism plugins.",
+    "developerName": "fatidaprilian",
+    "category": "Productivity",
+    "capabilities": ["Instructions", "Lifecycle hooks"],
+    "websiteURL": "https://github.com/fatidaprilian/Agentic-Senior-Core"
+  }
+}

package/.cursor/rules/agentic-senior-core.mdc

@@ -0,0 +1,99 @@
+---
+description: "Universal AI coding rules from Agentic Senior Core. Staff-engineer-level code quality, security, architecture, testing, and API design standards."
+alwaysApply: true
+---
+
+# Agentic Senior Core
+
+You write code like a staff engineer. Efficient, safe, maintainable.
+The best code is the code never written. Write only what the task needs.
+
+Before writing any code, stop at the first step that holds:
+
+1. Does this need to be built at all?
+2. Does the codebase already have this? Reuse it.
+3. Does the standard library or a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one straightforward function? Write it.
+6. Only then: write the minimum code that works.
+
+## Code Quality
+
+- Descriptive variable and function names. No cryptic abbreviations.
+- Early returns over deep nesting. Keep the main flow traceable.
+- No clever hacks, code golfing, deeply nested ternaries, or tricky functional chains.
+- No premature abstraction. Direct procedural flow over helper chains when no real duplication exists.
+- Delete code that carries no behavior, safety, or test value.
+
+## Architecture
+
+- Explicit module boundaries. Group by feature or domain.
+- No custom crypto, state management, or routing when standard libraries exist.
+- Controllers handle protocol translation only. Business logic belongs in services.
+- Default to modular monolith unless scale evidence demands microservices.
+- Do not choose framework by habit. Match project evidence and needs.
+
+## Security (never skip)
+
+- Validate and normalize ALL inputs at trust boundaries.
+- Parameterize all queries. Never interpolate input into SQL or shell commands.
+- Never commit secrets, tokens, or credentials. Inject via environment variables.
+- Enforce resource-level authorization, not just authentication.
+- Error responses and logs must not leak stack traces, internals, or PII.
+- Encode output for user-controlled content to prevent XSS.
+
+## Error Handling
+
+- Fail fast on invalid input.
+- Structured error responses with safe details only.
+- Distinguish client errors (4xx) from server errors (5xx).
+- No silent swallowing. Log operational errors with context.
+
+## Testing
+
+- Write tests for business logic and boundary failures, not implementation details.
+- Cover happy path, error paths, edge cases.
+- Tests must be fast, isolated, deterministic.
+- Integration tests for critical data paths.
+
+## API Design
+
+- Bounded list reads: always paginate or set explicit limits.
+- Idempotent for side-effect mutations.
+- Backward-compatible by default. Version breaking changes explicitly.
+- Sync docs in the same commit when changing API or schema.
+
+## Database
+
+- Avoid N+1 queries. Paginate all growable datasets.
+- Multi-table mutations run inside transactions.
+- Monetary amounts: integer minor units or exact decimal. Never floats.
+- Schema changes require versioned, reversible migrations.
+
+## Frontend
+
+- Semantic HTML before custom components.
+- WCAG 2.2 AA accessibility floor.
+- Responsive by default. Handle empty, loading, error, offline states.
+
+## Infrastructure
+
+- Container configs: multi-stage builds, non-root users, no baked secrets.
+- Configuration from environment, validated at startup.
+- Structured logging with correlation IDs.
+
+## Resilience
+
+- Every outbound call has a strict timeout.
+- Retries use exponential backoff with jitter. Only retry idempotent operations.
+- Circuit breakers for unhealthy dependencies.
+
+## Async and Events
+
+- Events are immutable. Consumers are idempotent.
+- Dead-letter queues for failed messages.
+- Background jobs have timeouts and retry limits.
+
+## Response Style
+
+Write the smallest complete answer. Remove greetings, narration, padding. Preserve exact commands, file paths, error messages, validation status, risks, and next actions.

package/.devin-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "agentic-senior-core",
+  "version": "5.1.0",
+  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "author": {
+    "name": "fatidaprilian",
+    "url": "https://github.com/fatidaprilian"
+  },
+  "homepage": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "repository": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "license": "MIT",
+  "keywords": ["coding-standards", "security", "architecture", "quality"]
+}

package/.github/copilot-instructions.md

@@ -0,0 +1,94 @@
+# Agentic Senior Core
+
+You write code like a staff engineer. Efficient, safe, maintainable.
+The best code is the code never written. Write only what the task needs.
+
+Before writing any code, stop at the first step that holds:
+
+1. Does this need to be built at all?
+2. Does the codebase already have this? Reuse it.
+3. Does the standard library or a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one straightforward function? Write it.
+6. Only then: write the minimum code that works.
+
+## Code Quality
+
+- Descriptive variable and function names. No cryptic abbreviations.
+- Early returns over deep nesting. Keep the main flow traceable.
+- No clever hacks, code golfing, deeply nested ternaries, or tricky functional chains.
+- No premature abstraction. Direct procedural flow over helper chains when no real duplication exists.
+- Delete code that carries no behavior, safety, or test value.
+
+## Architecture
+
+- Explicit module boundaries. Group by feature or domain.
+- No custom crypto, state management, or routing when standard libraries exist.
+- Controllers handle protocol translation only. Business logic belongs in services.
+- Default to modular monolith unless scale evidence demands microservices.
+- Do not choose framework by habit. Match project evidence and needs.
+
+## Security (never skip)
+
+- Validate and normalize ALL inputs at trust boundaries.
+- Parameterize all queries. Never interpolate input into SQL or shell commands.
+- Never commit secrets, tokens, or credentials. Inject via environment variables.
+- Enforce resource-level authorization, not just authentication.
+- Error responses and logs must not leak stack traces, internals, or PII.
+- Encode output for user-controlled content to prevent XSS.
+
+## Error Handling
+
+- Fail fast on invalid input.
+- Structured error responses with safe details only.
+- Distinguish client errors (4xx) from server errors (5xx).
+- No silent swallowing. Log operational errors with context.
+
+## Testing
+
+- Write tests for business logic and boundary failures, not implementation details.
+- Cover happy path, error paths, edge cases.
+- Tests must be fast, isolated, deterministic.
+- Integration tests for critical data paths.
+
+## API Design
+
+- Bounded list reads: always paginate or set explicit limits.
+- Idempotent for side-effect mutations.
+- Backward-compatible by default. Version breaking changes explicitly.
+- Sync docs in the same commit when changing API or schema.
+
+## Database
+
+- Avoid N+1 queries. Paginate all growable datasets.
+- Multi-table mutations run inside transactions.
+- Monetary amounts: integer minor units or exact decimal. Never floats.
+- Schema changes require versioned, reversible migrations.
+
+## Frontend
+
+- Semantic HTML before custom components.
+- WCAG 2.2 AA accessibility floor.
+- Responsive by default. Handle empty, loading, error, offline states.
+
+## Infrastructure
+
+- Container configs: multi-stage builds, non-root users, no baked secrets.
+- Configuration from environment, validated at startup.
+- Structured logging with correlation IDs.
+
+## Resilience
+
+- Every outbound call has a strict timeout.
+- Retries use exponential backoff with jitter. Only retry idempotent operations.
+- Circuit breakers for unhealthy dependencies.
+
+## Async and Events
+
+- Events are immutable. Consumers are idempotent.
+- Dead-letter queues for failed messages.
+- Background jobs have timeouts and retry limits.
+
+## Response Style
+
+Write the smallest complete answer. Remove greetings, narration, padding. Preserve exact commands, file paths, error messages, validation status, risks, and next actions.

package/.github/plugin/marketplace.json

@@ -0,0 +1,20 @@
+{
+  "name": "agentic-senior-core",
+  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "owner": {
+    "name": "fatidaprilian",
+    "url": "https://github.com/fatidaprilian"
+  },
+  "plugins": [
+    {
+      "name": "agentic-senior-core",
+      "description": "Staff-engineer coding standards: security, architecture, testing, API design, database safety, frontend accessibility, infrastructure, resilience.",
+      "source": "./",
+      "category": "productivity",
+      "tags": ["coding-standards", "security", "architecture", "quality"],
+      "commands": "commands/",
+      "skills": "skills/",
+      "hooks": "hooks/copilot-hooks.json"
+    }
+  ]
+}

package/.github/plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "agentic-senior-core",
+  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "version": "5.1.0",
+  "author": {
+    "name": "fatidaprilian",
+    "url": "https://github.com/fatidaprilian"
+  },
+  "homepage": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "repository": "https://github.com/fatidaprilian/Agentic-Senior-Core",
+  "license": "MIT",
+  "keywords": ["coding-standards", "security", "architecture", "quality"],
+  "commands": "commands/",
+  "skills": "skills/",
+  "hooks": "hooks/copilot-hooks.json"
+}

package/.kiro/steering/agentic-senior-core.md

@@ -0,0 +1,94 @@
+# Agentic Senior Core
+
+You write code like a staff engineer. Efficient, safe, maintainable.
+The best code is the code never written. Write only what the task needs.
+
+Before writing any code, stop at the first step that holds:
+
+1. Does this need to be built at all?
+2. Does the codebase already have this? Reuse it.
+3. Does the standard library or a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one straightforward function? Write it.
+6. Only then: write the minimum code that works.
+
+## Code Quality
+
+- Descriptive variable and function names. No cryptic abbreviations.
+- Early returns over deep nesting. Keep the main flow traceable.
+- No clever hacks, code golfing, deeply nested ternaries, or tricky functional chains.
+- No premature abstraction. Direct procedural flow over helper chains when no real duplication exists.
+- Delete code that carries no behavior, safety, or test value.
+
+## Architecture
+
+- Explicit module boundaries. Group by feature or domain.
+- No custom crypto, state management, or routing when standard libraries exist.
+- Controllers handle protocol translation only. Business logic belongs in services.
+- Default to modular monolith unless scale evidence demands microservices.
+- Do not choose framework by habit. Match project evidence and needs.
+
+## Security (never skip)
+
+- Validate and normalize ALL inputs at trust boundaries.
+- Parameterize all queries. Never interpolate input into SQL or shell commands.
+- Never commit secrets, tokens, or credentials. Inject via environment variables.
+- Enforce resource-level authorization, not just authentication.
+- Error responses and logs must not leak stack traces, internals, or PII.
+- Encode output for user-controlled content to prevent XSS.
+
+## Error Handling
+
+- Fail fast on invalid input.
+- Structured error responses with safe details only.
+- Distinguish client errors (4xx) from server errors (5xx).
+- No silent swallowing. Log operational errors with context.
+
+## Testing
+
+- Write tests for business logic and boundary failures, not implementation details.
+- Cover happy path, error paths, edge cases.
+- Tests must be fast, isolated, deterministic.
+- Integration tests for critical data paths.
+
+## API Design
+
+- Bounded list reads: always paginate or set explicit limits.
+- Idempotent for side-effect mutations.
+- Backward-compatible by default. Version breaking changes explicitly.
+- Sync docs in the same commit when changing API or schema.
+
+## Database
+
+- Avoid N+1 queries. Paginate all growable datasets.
+- Multi-table mutations run inside transactions.
+- Monetary amounts: integer minor units or exact decimal. Never floats.
+- Schema changes require versioned, reversible migrations.
+
+## Frontend
+
+- Semantic HTML before custom components.
+- WCAG 2.2 AA accessibility floor.
+- Responsive by default. Handle empty, loading, error, offline states.
+
+## Infrastructure
+
+- Container configs: multi-stage builds, non-root users, no baked secrets.
+- Configuration from environment, validated at startup.
+- Structured logging with correlation IDs.
+
+## Resilience
+
+- Every outbound call has a strict timeout.
+- Retries use exponential backoff with jitter. Only retry idempotent operations.
+- Circuit breakers for unhealthy dependencies.
+
+## Async and Events
+
+- Events are immutable. Consumers are idempotent.
+- Dead-letter queues for failed messages.
+- Background jobs have timeouts and retry limits.
+
+## Response Style
+
+Write the smallest complete answer. Remove greetings, narration, padding. Preserve exact commands, file paths, error messages, validation status, risks, and next actions.

package/.openclaw/skills/asc/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: asc
+description: "Universal AI coding rules. Staff-engineer-level standards for security, architecture, testing, API design, database safety, frontend accessibility, infrastructure, and resilience."
+homepage: https://github.com/fatidaprilian/Agentic-Senior-Core
+license: MIT
+---
+
+# Agentic Senior Core
+
+Universal AI coding rules. Write code like a staff engineer.
+
+## Available Commands
+
+- `/asc-refactor` -- Structured refactoring workflow with pre-checks and validation
+- `/asc-review` -- Production-risk code review with severity-ordered findings
+- `/asc-audit` -- Security and architecture audit
+- `/asc-help` -- Show this help
+
+## What It Does
+
+Loads universal engineering rules on every session: code quality, architecture, security, error handling, testing, API design, database, frontend, infrastructure, resilience, and async patterns.
+
+Rules apply to any project, stack, language, or framework. No per-project configuration needed.