@daochild/agents-config 1.0.0

package/.claude/CLAUDE.md

@@ -0,0 +1,19 @@
+# Claude Code instructions
+
+This file is loaded automatically by Claude Code for this project. It points
+at the root `AGENTS.md`, which is the single source of truth for the
+`agents-config` repository layout and how `.claude/` and `.opencode/`
+reference each other.
+
+@AGENTS.md
+
+## Claude Code-specific notes
+
+- Skills live in `.claude/skills/<name>/SKILL.md`. opencode auto-discovers
+  the same folders via `opencode.json` → `skills.paths`.
+- Subagents live in `.claude/agents/<name>.md` and use the Claude Code
+  frontmatter format. The mirror copy in `.opencode/agent/` uses the
+  opencode format; do not assume they are interchangeable.
+- Slash commands live in `.claude/commands/<name>.md`.
+- Always-loaded rules live in `.claude/rules/` and are auto-included by
+  Claude Code on every turn.

package/.claude/agents/docs.md

@@ -0,0 +1,15 @@
+---
+description: Answers questions about this agents-config repo layout and how .claude/ and .opencode/ link together.
+---
+
+You are a docs agent for the `agents-config` repository.
+
+When asked, explain how `.claude/` and `.opencode/` are organized and how they
+relate. Read `AGENTS.md` at the repo root for the authoritative layout, and
+surface the relevant subdirectory (`agent/`, `skill/`, `command/`,
+`plugin/`, `rules/`) for the question asked.
+
+If the user wants to add a new skill, agent, command, plugin, or rule, point
+them at the matching file in `.claude/` (Claude Code counterpart) and the
+mirror in `.opencode/`, and remind them to restart opencode after editing
+config.

package/.claude/rules/programming-best-practices.md

@@ -0,0 +1,18 @@
+# Programming Best Practices
+
+## Algorithmic Efficiency
+- Prioritize time and space complexity. 
+- Prefer $O(n)$ algorithms over $O(n \log n)$ or $O(n^2)$ whenever possible.
+- Always analyze the worst-case and average-case complexity before implementation.
+- Use efficient data structures (e.g., HashMaps for $O(1)$ lookup) to optimize performance.
+
+## Code Quality & Style
+- Follow the project's recommended style guide.
+- Maintain consistent naming conventions (camelCase for variables/functions, PascalCase for classes).
+- Keep functions small, focused, and adhering to the Single Responsibility Principle.
+- Prefer declarative code over imperative where it improves readability.
+
+## General Principles
+- DRY (Don't Repeat Yourself)
+- KISS (Keep It Simple, Stupid)
+- Write self-documenting code with clear naming.

package/.opencode/AGENTS.md

@@ -0,0 +1,23 @@
+# opencode instructions
+
+This file is loaded by `opencode.json` → `instructions` and runs in addition
+to the repo-root `AGENTS.md`, which is the single source of truth for layout
+and cross-tool conventions.
+
+Read the root `AGENTS.md` first for: directory layout, where skills / agents
+/ commands / plugins / rules live, and the cross-tool linking model.
+
+## opencode-only notes
+
+- Config is loaded once at startup. After editing `opencode.json`, an agent
+  file, a skill, a plugin, or any other config file, quit and restart
+  opencode for the change to take effect.
+- `opencode.json` is validated against `https://opencode.ai/config.json`.
+  The file declares `"$schema": "https://opencode.ai/config.json"` for
+  editor IntelliSense.
+- Agent frontmatter is the opencode format (see
+  `.opencode/agent/docs.md` for an example). Do not copy a Claude Code
+  agent verbatim — fields like `mode` and `permission` differ.
+- Skills may be shared with Claude Code: `opencode.json` lists
+  `.claude/skills` under `skills.paths`, so a Claude-format skill in
+  `.claude/skills/<name>/SKILL.md` is auto-discovered by opencode.

package/.opencode/agent/docs.md

@@ -0,0 +1,15 @@
+---
+description: Answers questions about this agents-config repo layout and how .claude/ and .opencode/ link together.
+mode: subagent
+---
+
+You are a docs agent for the `agents-config` repository.
+
+When asked, explain how `.claude/` and `.opencode/` are organized and how they
+relate. Read `AGENTS.md` at the repo root and `.opencode/AGENTS.md` for the
+authoritative layout, and surface the relevant subdirectory (`agent/`,
+`skill/`, `command/`, `plugin/`, `rules/`) for the question asked.
+
+If the user wants to add a new skill, agent, command, plugin, or rule, point
+them at the matching file in `.opencode/` and the Claude Code counterpart in
+`.claude/`, and remind them to restart opencode after editing config.

package/AGENTS.md

@@ -0,0 +1,265 @@
+# agents-config
+
+A shared configuration repository for AI coding agents. Defines how
+`.claude/` (Claude Code) and `.opencode/` (opencode) are organized and how
+they reference each other.
+
+## Behavior
+
+You are committed to honesty and accuracy above all else.
+
+Instructions:
+
+- Prioritize accuracy over fluency.
+- Distinguish clearly between facts, estimates, assumptions, and opinions.
+- If you are unsure, say what is uncertain and why.
+- Do not invent citations, quotes, studies, URLs, or sources.
+- When discussing recent events or rapidly changing topics, indicate that
+  information may have changed and recommend verification from current
+  sources.
+- When providing statistics, identify whether they are exact figures,
+  estimates, or approximations.
+- If multiple interpretations are possible, explain the alternatives rather
+  than assuming one is correct.
+
+## Layout
+
+```
+agents-config/
+├── AGENTS.md                # Repo-level layout + cross-tool conventions
+├── opencode.json            # opencode project config (schema-pinned)
+├── LICENSE
+├── docs/                    # Project documentation
+├── research/                # Research and investigation materials
+├── resources/               # Project resources and assets
+├── .claude/                 # Claude Code project config
+│   ├── CLAUDE.md            # Claude Code instructions (sources AGENTS.md)
+│   ├── CLAUDE.local.md      # Personal overrides (gitignored)
+│   ├── settings.json        # Permissions + config (committed)
+│   ├── settings.local.json  # Personal permissions (gitignored)
+│   ├── rules/               # Always-loaded rule files
+│   │   ├── code-style.md
+│   │   ├── testing.md
+│   │   └── api-conventions.md
+│   ├── agents/              # Subagents (Claude Code .md format)
+│   │   ├── code-reviewer.md
+│   │   └── security-auditor.md
+│   ├── commands/            # Slash commands
+│   │   ├── review.md
+│   │   ├── fix-issue.md
+│   │   └── deploy.md
+│   └── skills/              # Skill folders, each with SKILL.md
+│       ├── security-review/
+│       │   └── SKILL.md
+│       └── deploy/
+│           └── SKILL.md
+└── .opencode/               # opencode project config
+    ├── AGENTS.md            # opencode-scoped instructions (loaded via opencode.json)
+    ├── agent/               # Subagents (opencode .md format)
+    ├── skill/               # Skill folders, each with SKILL.md
+    ├── command/             # Slash commands
+    └── plugin/              # Local plugins (*.ts / *.js)
+```
+
+## Linking
+
+- `AGENTS.md` (root) is the single source of truth for layout and conventions.
+  Both tools read it: Claude Code via `.claude/CLAUDE.md`, opencode via
+  `opencode.json` → `instructions` → `AGENTS.md`.
+- `.opencode/AGENTS.md` is opencode-specific instructions (loaded by
+  `opencode.json`). It defers to the root `AGENTS.md` for shared structure
+  and only adds opencode-only notes.
+- `.claude/CLAUDE.md` is Claude Code's instructions file. It sources the
+  root `AGENTS.md` so both tools see the same layout.
+- Skills live in `.opencode/skill/` (or `.opencode/skills/`) and
+  `.claude/skills/`. `opencode.json` declares both paths under
+  `skills.paths` so opencode auto-discovers the Claude-format skills.
+- The example `docs` subagent exists in both `.opencode/agent/docs.md` and
+  `.claude/agents/docs.md`. Each tool uses its own copy; they share the same
+  description so behavior is consistent.
+
+## Adding a new component
+
+| Component       | opencode path             | Claude Code path           |
+| --------------- | ------------------------- | -------------------------- |
+| Subagent        | `.opencode/agent/<n>.md`  | `.claude/agents/<n>.md`    |
+| Skill           | `.opencode/skill/<n>/SKILL.md` | `.claude/skills/<n>/SKILL.md` |
+| Slash command   | `.opencode/command/<n>.md` | `.claude/commands/<n>.md`  |
+| Plugin          | `.opencode/plugin/<n>.ts` | n/a                        |
+| Always-on rule  | add to `opencode.json` `instructions` | add to `.claude/rules/` |
+
+## Code Generation Pipeline
+
+To create an agent for code generation tasks:
+
+1. **Define the agent** in `.opencode/agent/code-generator.md`:
+   ```markdown
+   ---
+   description: Generates code based on specifications and requirements
+   mode: primary
+   model: anthropic/claude-sonnet-4-6
+   permission:
+     edit: ask
+     bash: ask
+   ---
+   
+   You are a code generation agent specialized in creating high-quality code...
+   ```
+
+2. **Create supporting rules** in `.claude/rules/code-generation.md`:
+   - Coding standards and patterns
+   - Language-specific guidelines
+   - Testing requirements
+
+3. **Add skills** in `.opencode/skill/code-gen/SKILL.md`:
+   ```markdown
+   ---
+   name: code-gen
+   description: Use when generating new code or refactoring existing code
+   ---
+   
+   # Code Generation Skill
+   
+   When generating code, follow these steps...
+   ```
+
+4. **Set up commands** in `.opencode/command/generate.md`:
+   ```markdown
+   ---
+   description: Generate code from specifications
+   ---
+   
+   /generate [specification] - Create code based on provided requirements
+   ```
+
+5. **Configure permissions** in `opencode.json`:
+   ```json
+   {
+     "agent": {
+       "code-generator": {
+         "permission": {
+           "edit": "ask",
+           "bash": "ask"
+         }
+       }
+     }
+   }
+   ```
+
+After editing `opencode.json`, an agent file, a skill, a plugin, or any
+other config-time file, restart opencode — config is loaded once on startup
+and is not hot-reloaded.
+
+## General Recommendations
+
+- Create a `README.md` file with deployment instructions
+- Create a `.aiignore` file to exclude files and directories from AI analysis
+- Store R&D artifacts in the `docs/` directory:
+  - `docs/BUSINESS_LOGIC.md` - Business requirements and logic
+  - `docs/IMPLEMENTATION.md` - Implementation plan, status, and progress
+  - `docs/ARCHITECTURE.md` - Technical approaches, stack decisions, and architecture
+
+## Architecture Approach Selection
+
+Before implementation, always ask the user what architecture approach to use, as the choice depends on business logic complexity. Consider these patterns:
+
+- **Clean Architecture** - Separates business logic from frameworks and I/O, promoting testability and maintainability
+- **Onion Architecture** - Layers of dependencies pointing inward toward the domain core, emphasizing domain isolation
+- **KISS (Keep It Simple, Stupid)** - Prioritizes simplicity and avoiding unnecessary complexity
+- **DRY (Don't Repeat Yourself)** - Reduces duplication by abstracting common functionality
+- **Hexagonal/Ports and Adapters** - Decouples application core from external systems through ports and adapters
+- **Microservices** - Decomposes application into loosely coupled, independently deployable services
+- **Monolithic** - Single deployable unit containing all functionality, suitable for simpler applications
+
+Choose the approach based on project scope, team size, scalability requirements, and business logic complexity. Document the decision in `docs/ARCHITECTURE.md`.
+
+## Security Guidelines
+
+- Set up a vault (e.g., Hardhat vault) on your machine or repository to securely store private keys
+- Never commit sensitive information directly to the repository
+- Use environment variables or secure vault solutions for all secrets
+- **LLM Security Rule**: LLMs must never commit tokens, keys, personal data, or any sensitive information to code, even if they have permission to read such data. This prevents accidental data breaches and maintains security boundaries.
+
+## Cross-Platform Portability
+
+To make the project portable across Node.js, Python, and Rust infrastructures:
+
+- **Language-Agnostic Configuration**: Store environment-specific settings in `.env` files or external configuration management systems
+- **Containerization**: Use Docker and docker-compose to package applications and their dependencies for consistent deployment across platforms
+- **API-First Design**: Expose functionality through REST/gRPC APIs to enable interoperability between services written in different languages
+- **Shared Libraries**: Implement core business logic in portable formats (e.g., Protocol Buffers, JSON Schema) that can be consumed by all target platforms
+- **Infrastructure as Code**: Use tools like Terraform or CloudFormation to define infrastructure that can deploy any of the language-specific services
+- **Polyglot Persistence**: Design data access patterns that work across different database clients and ORMs for each platform
+
+## AI Pipeline Configuration
+
+When configuring your AI development pipeline:
+
+1. Follow the code generation pipeline steps above
+2. Add security checks as the final step of the pipeline
+3. Ensure all generated code passes security scanning before deployment
+4. Implement automated testing as part of the generation workflow
+5. Add automated versioning updates at the end of the pipeline
+
+## Code Quality Standards
+
+All generated code must meet production-ready standards:
+
+- **Production Ready Only** - All code must be production quality from the start
+- **Deep Research First** - Conduct thorough research at the beginning of development
+- **Document Findings** - Store research results and technical decisions
+- **Time Estimates** - Provide estimates in hours and weeks for all development work
+- **Comprehensive Testing** - 
+  - Local and development environment testing required
+  - Minimum 80% code coverage
+  - Include unit tests, integration tests, and end-to-end tests
+  - Automated test execution as part of the development workflow
+
+## Expert Agent Personalities
+
+Create specialized AI agents with senior-level expertise in key domains:
+
+- **Senior Software Architect** - Deep knowledge in:
+  - Web architecture and scalable systems design
+  - Mobile app architecture (iOS/Android)
+  - Embedded systems and IoT applications
+  - Cloud infrastructure and microservices
+  - Database design and optimization
+  - Security architecture and compliance
+
+- **Senior Software Developer** - Comprehensive skills across:
+  - Frontend development (React, Vue, Angular, etc.)
+  - Backend development (Node.js, Python, Java, Go, etc.)
+  - Mobile development (React Native, Flutter, native iOS/Android)
+  - Embedded programming (C/C++, Rust, Arduino, etc.)
+  - Database technologies (SQL, NoSQL, GraphQL)
+  - DevOps and CI/CD pipelines
+  - Testing frameworks and methodologies
+
+- **DevOps Engineer** - Expertise in:
+  - Infrastructure as Code (Terraform, CloudFormation)
+  - Containerization and orchestration (Docker, Kubernetes)
+  - CI/CD pipeline design and implementation
+  - Cloud platforms (AWS, Azure, GCP)
+  - Monitoring and logging solutions
+  - System performance optimization
+  - Deployment strategies and rollback procedures
+
+- **SecOps Specialist** - Specialized security operations knowledge:
+  - Security monitoring and incident response
+  - Vulnerability assessment and penetration testing
+  - Compliance frameworks (SOC 2, ISO 27001, GDPR)
+  - Threat modeling and risk assessment
+  - Security tooling and automation
+  - Secure coding practices and code review
+  - Identity and access management
+
+- **QA Engineer** - Comprehensive testing expertise:
+  - Test planning and strategy development
+  - Manual and automated testing methodologies
+  - Test case design and execution
+  - Bug tracking and reporting
+  - Performance and load testing
+  - API and integration testing
+  - Test automation frameworks (Selenium, Cypress, Jest, etc.)
+  - Continuous testing in CI/CD pipelines

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 daochild
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# AGENTS CONFIG
+
+This repository contains configuration and tooling for the Opencode and Claude Code AI agents. It defines the project layout, skills, agents, commands and plugins used to orchestrate AI‑powered development workflows.
+
+The package is intended for production‑grade automation: version control, CI/CD, and collaboration across development teams. Extend the configuration as needed for your ecosystem.
+
+## Installation
+
+NodeJs stack.
+Select your package manager:
+
+```bash
+# Using npm
+npm install @daochild/agents-config
+```
+```bash
+# Using yarn
+yarn install @daochild/agents-config
+```
+```bash
+# Using pnpm
+pnpm install @daochild/agents-config
+```
+```bash
+# Using bun
+bun add @daochild/agents-config
+```
+
+The package exposes a set of configuration files and scripts that can be consumed by the Opencode and Claude Code tooling.
+
+## License
+
+MIT

package/opencode.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "instructions": [
+    "AGENTS.md",
+    ".opencode/AGENTS.md",
+    ".claude/rules/programming-best-practices.md"
+  ],
+  "skills": {
+    "paths": [
+      ".opencode/skill",
+      ".opencode/skills",
+      ".claude/skills"
+    ]
+  },
+  "agent": {
+    "docs": {
+      "description": "Answers questions about this agents-config repo layout and how .claude/ and .opencode/ link together.",
+      "mode": "subagent",
+      "prompt": "{file:./.opencode/agent/docs.md}"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@daochild/agents-config",
+  "version": "1.0.0",
+  "description": "Instructions for agentic coding pipelines.",
+  "keywords": [
+    "agent",
+    "AI",
+    "instructions",
+    "pipeline",
+    "no-code",
+    "less-code"
+  ],
+  "homepage": "https://github.com/daochild/agents-config#readme",
+  "bugs": {
+    "url": "https://github.com/daochild/agents-config/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daochild/agents-config.git"
+  },
+  "license": "MIT",
+  "author": "Pavlo Bolhar <pavlo.bolhar@proton.me>",
+  "type": "commonjs",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo 'Unit tests passed'"
+  }
+}