AgentStack
SKILL verified MIT Self-run

Deployment

skill-jkvetina-ai-skills-deployment · by jkvetina

Oracle APEX deployment process — environment strategy, Git branching, developer workflow, release and hotfix procedures, QA checks, CI/CD automation, and ADT tooling. Use this skill whenever planning, reviewing, or executing deployments, setting up CI/CD pipelines, configuring Git branching strategy, preparing patches, reviewing pull requests against deployment standards, onboarding developers to…

No reviews yet
0 installs
6 views
0.0% view→install

Install

$ agentstack add skill-jkvetina-ai-skills-deployment

✓ scanned · ✓ verified — works with Claude Code, Cursor, and more.

Security review

✓ Passed

No issues found. Passed automated security review. · v0.1.0 How review works →

  • Prompt-injection patterns
  • Secret / credential exfiltration
  • Dangerous shell & filesystem operations
  • Untrusted network calls
  • Known-malicious package signatures

What it can access

  • Network access No
  • Filesystem access No
  • Shell / process execution No
  • Environment & secrets No
  • Dynamic code execution No

From automated source analysis of v0.1.0. “Used” means the capability is present in the source — more access means more to trust, not that it’s unsafe.

Are you the author of Deployment? Claim this listing to set pricing, connect Stripe payouts, and keep 70% of every sale.
Sign up to claim

About

Oracle APEX Deployment Process

This skill defines the complete deployment process for Oracle APEX projects. It covers environment strategy, version control, development workflow, release and hotfix procedures, QA checks, CI/CD automation, and tooling.

The full process document is in references/process.md. Read it when you need the complete details. Below is a summary of each section and guidance on when to consult it.

Stamp

On success, run: python3 /Users/dobby/Library/CloudStorage/Dropbox/BRAIN/AI/SCRIPTS/skills_log.py stamp deployment

When to use this skill

  • Reviewing a pull request — check the PR Approval Criteria (section 3) for the full checklist.
  • Preparing a patch — follow the developer task workflow (section 3, steps 6–7) and the patch folder convention.
  • Setting up or reviewing CI/CD — consult section 7 for branch protection, Git hooks, CI pipeline steps, and deployment process.
  • Planning a release — follow the release workflow (section 4) for branching, tagging, and merge steps.
  • Handling a production issue — follow the hotfix workflow (section 5) for the urgent fix process.
  • Onboarding a developer — the full document serves as the onboarding reference.
  • Checking QA requirements — section 6 covers automated checks, manual verification, and client confirmation.

Key principles

  • Two environments minimum: DEV (dev branch) and PROD (main branch). No skipping environments.
  • Feature-to-environment merges only: never merge one environment branch into another. Each task stays independently deployable.
  • Squash merge into environment branches to prevent false conflicts and keep history clean.
  • Rebase feature branches onto dev or main to stay current — never merge the other direction.
  • One patch per task: never combine multiple tasks into one script.
  • Per-task acceptance criteria: defined before work starts, verified by developer, reviewer, and QA.
  • Deploy tasks individually when possible for short feedback loops. Group into releases only when needed.

Developer task workflow (summary)

  1. Pick up a task — verify acceptance criteria exist.
  2. Create a feature branch from dev: feat/{task_id}/{description}.
  3. Write unit tests before implementation (85% coverage threshold).
  4. Implement changes.
  5. Export and commit regularly (at least daily, even work in progress).
  6. Prepare the patch with adt patch — one patch per task.
  7. Verify the patch on DEV.
  8. Rebase onto main.
  9. Self-review: acceptance criteria, formatting, security, performance.
  10. Create a pull request.

For the full details on each step, read references/process.md section 3.

PR approval checklist (summary)

  • Git diff is correct and complete.
  • Acceptance criteria fulfilled.
  • Code formatting, error handling, and security standards met.
  • No hardcoded credentials, no SQL injection risks.
  • Performance reviewed.
  • Unit tests pass with 85% coverage.
  • Patch script is correct, deployment log is clean.
  • APEX exports (split, readable, embedded code report) present.

For the full checklist, read references/process.md section 3 (Pull Request Approval Criteria).

Deployment process (summary)

  1. Connect securely to the target instance.
  2. Execute patch scripts in A–Z order.
  3. Run post-deployment checks (invalid objects, object counts, APEX stats).
  4. Store deployment log with [SUCCESS] or [ERROR] suffix.
  5. Archive successful patches from patches/ to patches_done/.
  6. If release branch: merge into main.
  7. On failure: notify all involved, stop subsequent patches.

For the full details, read references/process.md section 7.

Task board statuses

BacklogTodoIn ProgressIn ReviewDoneDelivered

Only Todo, In Progress, In Review, and Done are visible on the board. Swimlanes per developer.

Related skills

  • adt — ADT command reference and flags
  • apex-qa — APEX application quality standards
  • plsql-formatter — PL/SQL formatting standards
  • plsql-code-quality — PL/SQL code quality guidelines
  • data-model — Database design standards
  • apex-rest — REST service standards

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

Install and usage instructions live in the source repository linked above.

Reviews

No reviews yet — be the first.

Versions

  • v0.1.0 Imported from the upstream source.