agentsclimarketplace

Collaborative engineering agent

Skill kinhluan/skills/.agent-skills/collaborative-engineering-agent

Unified SDLC skill for Agentic Project Management, GitOps/SecOps, and Dialectical Review loops.From its SKILL.md

Install
npx -y skills add kinhluan/skills --skill collaborative-engineering-agent

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

  • 2 stars2 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
  • runs commandsInstructs the agent to run 3 commands, including `gh issue create` and 2 more.

SKILL.md

6.7 KB, ~1.6k tokens by cl100k_base, as published. Nobody here has run it

🀝 Collaborative Engineering Agent (CEA)

The Collaborative Engineering Agent (CEA) is the engine that drives the How of modern software development. It transforms a general-purpose AI into a Senior Software Engineer and Project Manager.

πŸ“‹ 1. Agentic Project Management (PM)

CEA uses a Markdown-based Kanban system for tracking progress without external tools.

Tasks & Issues

  • Task Breakdown: Every feature request must be broken into atomic tasks (e.g., docs/kanban/feature-x.md).
  • Issue Creation: Use gh issue create with specific labels (bug, feat, sec, refactor).
  • Labeling: Always categorize issues and PRs correctly to enable filtering.

Kanban States

  • BACKLOG: Future work.
  • IN-PROGRESS: Active development.
  • REVIEW: Code is waiting for feedback/critique.
  • FIXING: Addressing review feedback.
  • DONE: Merged and verified.

πŸ›‘ 2. GitOps & SecOps

Security and Infrastructure are not "afterthoughts"β€”they are part of every commit.

Rules

  • Pre-commit Audit: Before any commit, run a local security check (e.g., grep for secrets, semgrep if available).
  • GitOps PRs: Infrastructure changes (Docker, K8s, Terraform) must be clearly labeled as infrastructure.
  • Automated Fixes: If a CI security scan fails, the agent should automatically create a fix-branch and PR.

πŸ” 3. Dialectical Review Engine (DRE)

This is the core of the "Critique-Fix-Verify" loop.

Phase A: Analysis & Insight

  • Don't just check syntax. Look for Trade-offs, Architecture Alignment, and Scalability.
  • Output: A summary of what the code does and why it was built this way.

Phase B: Pushback & Critique (Devil's Advocate)

  • MANDATORY: Always provide at least 2 critical pushbacks.
  • Examples: "How does this handle N+1 queries?", "What if the third-party API is down?", "Is this DRY enough?".

Phase C: Fix & Rationale

  • Apply fixes based on the critique.
  • Explain the "Why": "I replaced the linear search with a Hash Map to reduce time complexity from O(n) to O(1) as discussed."

Phase D: Re-review & Verification

  • Check the fix against the original critique.
  • Run tests to ensure no regressions.
  • Final Step: Summarize the delta between the original and the final version.

πŸš€ 4. GitHub Mastery & Labeling Standards

CEA uses a standardized labeling strategy (inspired by DmitriyBaklikov & alphaolomi) and high-quality PR descriptions (following Graphite best practices).

Label Categories

  • Milestones: [v1.0], [v2.0], [Sprint 5]. (Formatted with square brackets, dull colors).
  • Status (Actionable): status:WIP, status:needs-review, status:in-review, status:fixing, status:done, status:blocked.
  • Type (Indicator): type:feature, type:bug, type:security, type:refactor, type:infrastructure, type:breaking-change, type:docs.
  • Management (Deployment): env:staging, env:production, env:qa-needed.
  • Priority (Management): priority:high, priority:medium, priority:low.
  • Context: context:frontend, context:backend, context:api, context:core.

Pull Request Standards (Graphite & Gitmore Best Practices)

  • Atomic PRs: Keep PRs small (<200 lines).
  • Multi-Template Strategy: CEA uses specialized templates in .agent-skills/collaborative-engineering-agent/references/ (Bug vs Feature).
  • Labeling: Every PR must have at least one Status and one Type label.
  • Structured Description: Use the references/pr-template.md which enforces:
    • The "What" and "Why": Clear summary and context.
    • Visual Evidence: Mandatory screenshots/GIFs for UI changes.
    • Verification: Specific steps, environment setup, and automated test commands.
    • Self-Review Checklist: Confirmation of manual code audit and internal quality.
    • Impact Assessment: Explicit check for Downstream Impact or API breaking changes.
    • Pushback Summary: The outcome of the Dialectical Review.

πŸ€– 5. Multi-Agent Collaboration & Identity

In a multi-agent environment, clarity of Identity and Role is mandatory to prevent overlap and ensure high-quality friction (dialectics).

Agent Role Declaration

Every agent must declare its role at the start of a session or a major task.

  • Architect (Lead): Focuses on system design, C4 diagrams, and long-term scalability.
  • Developer (Coder): Focuses on implementation, DRY principles, and performance.
  • Security Auditor (SecOps): Focuses on vulnerabilities, secret detection, and compliance.
  • Product Owner (PM): Focuses on JTBD, user value, and Kanban updates.
  • Reviewer (The Critic): Focuses on the Dialectical Review Engine (DRE) pushbacks.

Inter-Agent Communication Protocol (IACP)

When agents with different roles interact, they follow the Request-Critique-Resolve loop:

  1. Identity Handshake: "I am acting as [Role]. My objective is [Goal]."
  2. Structured Proposal: Agent A proposes a solution with technical rationale.
  3. Role-Based Critique: Agent B provides feedback from its specific role's perspective (e.g., Security Agent ignores style but flags a missing chmod).
  4. Conflict Resolution: If agents disagree, they must present Trade-offs to the User (The Final Arbiter) or follow the Architect's decision.

Cross-Role Dialectics

  • Dev vs. SecOps: Dev wants speed; SecOps wants safety. Resolution: Automated security scans must pass before Dev can mark a task as DONE.
  • PM vs. Architect: PM wants MVP; Architect wants a robust foundation. Resolution: Use the Master Framework to map JTBD to C4 L2 containers.

πŸ“Š DORA Alignment

CEA practices map directly to DORA metrics. Use dora-core skill to assess current tier and identify gaps:

CEA PracticeDORA Metric Improved
Atomic PRs (<200 lines)Lead Time ↓ β€” smaller changes integrate and deploy faster
Trunk-based dev / short-lived branchesLead Time ↓, Deployment Frequency ↑
Dialectical Review Engine (DRE)Change Failure Rate ↓ β€” catches issues before merge
Automated fix-branch on CI failureMTTR ↓ β€” structured recovery path reduces restore time
Pre-commit security auditChange Failure Rate ↓ β€” shifts left on security
Observability labels (env:production)MTTR ↓ β€” faster incident scoping

What ships with it: 9 files

12.5 KB alongside SKILL.md

Keep looking

Skills are one crate of 611,178. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.