Event‑Driven Development Automation: Turning Local Git Actions into Cross‑System Collaboration

Core Idea

SKILL treats local native development actions as trusted events, persisting the essential information of each development task lifecycle. Within a single IDE/agent window it converts those events into coordinated operations across multiple systems (PMS, Lark, GitLab, CI/CD, PaaS, release‑management), automating the long‑cycle, multi‑task workflow that previously required repetitive manual steps.

Target Audience

Developers, testers and collaboration partners who need to manage feature development, progress tracking, test coordination, delivery and release.

Problems Addressed

Developers must manually create or bind PMS tickets, switch IDE branches, update PMS status, write documentation in Lark Wiki, notify testers, create merge requests, wait for review, merge branches, tag releases, trigger CI/CD pipelines, deploy to PaaS and finally update release‑management status – a fragmented, error‑prone process.

Each stage incurs context loss, duplicate data entry, delayed notifications and high coordination overhead.

Design Shift

Instead of manual, step‑by‑step actions, developers now issue high‑certainty commands (e.g., "create branch", "push", "create MR", "tag") from a unified CLI. SKILL captures these events, enriches them with persisted context, and triggers downstream automation while keeping humans in the loop for critical decisions.

Overall Architecture

The solution is organized into six layers:

Trigger Layer : Git hooks (post‑checkout, prepare‑commit‑msg, commit‑msg, pre‑push) and an interactive CLI capture low‑interference, high‑certainty events.

Orchestration Layer : Maps events to ordered actions, applies branch strategies, state‑machine transitions, AI profiling and notification policies.

Domain Capability Layer : Implements end‑to‑end functions – create/bind PMS tickets, progress summarisation, test hand‑off, code trace, MR/Review handling, tagging, release and final deployment.

Adapter Layer : Reuses authentication and APIs of external systems (PMS, Lark, GitLab, release‑mgmt, email, LLM CLI) while isolating implementation details.

State Layer : Local maps (branch‑issue, branch‑doc, processed‑branches, push‑sync‑state) provide traceability, de‑duplication and recoverability without polluting the business repository.

Platform Hand‑off Layer : Consumes branch or tag events to run CI/CD pipelines, build Docker images, deploy via PaaS and close release‑management tickets.

High‑Certainty Events

Branch creation, commit, push, test hand‑off, MR creation, merge and tag have clear semantics and are suitable as automation triggers. Noisy actions such as file edits or temporary debugging are ignored to keep the automation trustworthy.

Event‑Driven Workflow

The branch name serves as the primary key that links code, PMS tickets, documentation and notifications. SKILL records the mapping "repo + branch → PMS‑KEY, Lark‑doc‑URL" and uses it to auto‑populate MR descriptions, reviewer assignments, tag messages and release notes. Code‑blame can later retrieve the original author, branch and ticket.

End‑to‑End Example

Start: Developer runs git checkout -b feature/intl‑debug‑agent. The post‑checkout hook creates a technical PMS ticket and moves it to "In Progress".

Develop: prepare‑commit‑msg appends the PMS ID to the commit message; the first git push adds a comment with a link to the branch in PMS.

Increment: Subsequent pushes generate a structured change summary (added/modified/deleted files) and an asynchronous AI summary is posted to the ticket.

Test Hand‑off: Executing the "branch‑test" command updates the test level in PMS, creates a test MR, generates or updates the feature documentation in Lark and notifies the tester.

Review & Merge: The "merge‑main" command creates a merge request, attaches PMS context, performs a dry‑run preview, and notifies the assignee. If approved, the MR is merged.

Tag & Delivery: After merging to master, the "create‑tag" command tags the commit; the tag event triggers CI/CD image build, PaaS deployment and updates PMS status.

Release Completion: The "branch‑release" command queries the related release‑application, advances its status to "Completed", and sends a final Lark notification to the requestor and pre‑release testers.

Idempotence and Degradation

Duplicate tickets are detected by title; processed branches are recorded to avoid repeat prompts.

Push SHA signatures prevent duplicate comments.

Lark notifications use an idempotent key.

Each step can be disabled independently (AI summarisation, comment sync, documentation, notifications).

Failures are logged but never block the Git workflow; a dry‑run preview is required before any high‑impact action.

Automation Controls

Field rejections in Jira are retried up to three times.

AI, comment sync, doc generation and notifications can be turned off.

All external failures are logged without interrupting the main Git chain.

Dry‑run mode shows the exact actions before execution; the --yes flag is required to bypass confirmation.

Design Principles

Use event contracts rather than monolithic scripts to keep each system replaceable.

Separate deterministic rule‑driven actions (ticket creation, status transition) from AI‑driven understanding and summarisation.

Maintain a single source of truth (the local skill + hooks) that can be cloned and automatically installed.

Benefits

One‑Window Operation : Developers issue intent once in the IDE/agent; SKILL handles all downstream actions.

Full‑Traceability : Code, branch, PMS ticket, documentation, MR, tag and deployment events are linked, reducing reliance on verbal sync across time zones.

Automation + Human Compatibility : Automatic ticket creation, optional manual binding, explicit overrides and interactive confirmations coexist.

Stability First : Asynchronous AI, failure‑tolerant fallbacks, signature de‑duplication keep the pipeline robust.

Responsibility Decoupling : SKILL orchestrates; GitLab/CI/CD/PaaS execute their specialised tasks.

Dual Closed‑Loop : PMS "Deployed" status and release‑application "Completed" status are updated independently but via the same unified intent.

Configurable Strategy : Project, issue type, module, personnel, branch and reviewer policies are all configurable and reusable across teams.

Single Source of Truth : The global skill repository plus hooks act as the authoritative definition; cloning a repo automatically installs the automation.

In summary, SKILL enables developers to focus on local coding while the agent records the full task lifecycle, automatically drives cross‑system entry, flow, documentation and notification, and lets the underlying platform complete testing and release, turning a fragmented manual process into an event‑driven, platform‑hand‑off, fully traceable workflow.