# application-packager

Adopt this skill: https://proskills.md/skills/other/kyoungbinkim-give-me-job-skills-application-packager

Page: https://proskills.md/skills/other/kyoungbinkim-give-me-job-skills-application-packager
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/application-packager/SKILL.md
size: 4412
upstream: https://github.com/kyoungbinkim/give-me-job/blob/main/skills/application-packager/SKILL.md

````text
---
name: application-packager
description: Create a company-specific job application package from a JD, resume.md, cover letter drafts, HR review, and optional company values input. Use when the user wants 지원 패키지, submission checklist, application folder structure, final answer snippets, email draft support, or safe pre-submission preparation without automatic final submission.
---

# Application Packager

Create submission-ready materials, but do not submit applications automatically.

## Trigger

Use this skill after the JD analysis, cover letter draft/final, evidence map, HR review, and optional interview prep are ready or when the user asks to assemble a final Korean application package.

## Do Not Trigger

Do not use this skill to bypass HR review, submit an application, send email, log in, solve CAPTCHA, or transmit personal information.

## Autonomy Level

**DoF: LOW**

Create and validate the package structure deterministically. Do not mark an application submitted unless the user explicitly confirms manual submission.

Permitted inferences:

- ASCII package slug from company and role.
- Missing package files from the canonical package structure.

Prohibited inferences:

- Do not create unsupported cover letter claims.
- Do not invent deadlines, required documents, or submission status.

## Input Contract

Required context:

- Company name and role name.
- JD or `applications/<company-role>/jd-analysis.md`.
- `resume.md`.
- Cover letter draft or final.
- `applications/<company-role>/evidence-map.md`.
- `applications/<company-role>/hr-review.md`.

Optional context:

- Company values analysis.
- `applications/<company-role>/interview-prep.md`.
- Deadline, file requirements, and length limits.

Required parameters:

- `company`: target company name.
- `role`: target role title.

Outputs produced:

- `applications/<company-role>/workflow.md`
- `applications/<company-role>/submission-checklist.md`

## Inputs

- company name
- role name
- JD or JD analysis
- `resume.md`
- cover letter draft or final
- optional company values analysis
- deadline, file requirements, and length limits if available

## Workflow

1. Normalize the application slug as `company-role`.
2. Create or propose the package structure from `references/package-structure.md`.
3. Save JD analysis, company values analysis, cover letter draft/final, evidence map, and checklist.
4. Save interview preparation when available.
5. Check company name, role name, file names, length limits, and required attachments.
6. Prepare manual submission snippets or email draft text when requested.
7. Record submission status only after the user confirms what happened.
8. Run structure validation for newly initialized templates. Run ready validation
   for completed answers, checking required questions, length rules, evidence
   references, completed current final review, and unresolved blockers. Only
   successful ready validation records `ready-for-user-review`.

Use `state.json` as the machine-readable preparation state and generate the
`workflow.md` status summary from it. Keep recruitment progress in the tracker.
Record interruption reasons and next actions; reuse completed steps only while
their reviewed input hashes remain current. Legacy packages without current
review metadata require revalidation and remain readable without overwriting
their existing prose. User risk acceptance never waives unresolved blockers.

An AI request from CLI, TUI, or dashboard is a prepared prompt, not a completed
package. Execute it in the existing agent, save the requested files, validate,
and reload the interface. Installation, upgrade, and uninstall must not touch
resume facts, saved jobs, tracking data, or application packages.

## Hard Rules

- Do not click or trigger a final submit/send action.
- Do not bypass CAPTCHA, login, payment, consent, or sensitive personal information prompts.
- Do not create unsupported claims that are absent from `resume.md`.
- Do not auto-create user data during skill installation. Create files only when the user asks during a task.

## Output

```md
## Application Package
- Company:
- Role:
- Deadline:
- Package Path:
- Included Files:
- Missing Inputs:
- Interview Prep:
- Submission Checklist:
- Manual Submission Notes:
```

## Fallback

If final cover letter text is not ready, call for `cover-letter-writer` and `hr-reviewer` work before packaging.
````

## File: README.md
upstream: https://github.com/kyoungbinkim/give-me-job/blob/main/README.md

````text
# give-me-job

![give-me-job banner](docs/assets/give-me-job-banner.jpg)

[![npm version](https://img.shields.io/npm/v/give-me-job.svg)](https://www.npmjs.com/package/give-me-job)
[![CI](https://github.com/kyoungbinkim/give-me-job/actions/workflows/ci.yml/badge.svg)](https://github.com/kyoungbinkim/give-me-job/actions/workflows/ci.yml)
[![Node.js 18.17+](https://img.shields.io/badge/Node.js-18.17%2B-339933?logo=node.js&logoColor=white)](docs/platform-support.md)

`give-me-job` is an AI agent toolkit for Korean job applications. It helps you turn scattered career notes, a Korean job post, and company context into a focused application package: JD analysis, evidence-grounded 자기소개서 drafts, HR risk review, interview defense, and a manual submission checklist.

Most job-application tools optimize for speed. `give-me-job` optimizes for confidence: every strong claim should trace back to your `resume.md`, every risky sentence gets reviewed before final use, and every final answer should be something you can defend in an interview.

Use it when you want an agent to help with 취업준비 without inventing experience, exaggerating metrics, or auto-submitting applications. The current demo focuses on a backend role, but the workflow is designed for Korean job applications across tech, business, support, creative, and operations roles. This repository prepares the materials; you stay in control of review and final submission.

Korean search keywords: 자기소개서, 취업준비, 한국 취업, 취업 에이전트, 개발자 취업준비, 개발자 자기소개서.

Use [`agent.md`](agent.md) as the orchestrator for the full workflow. Repository-level agent instructions are in [`AGENTS.md`](AGENTS.md). Korean documentation is available at [`docs/README-ko.md`](docs/README-ko.md).

**See the output before you install** — a complete demo application package is committed to this repository:
[`examples/demo-new-grad-backend/applications/demo-cloud-backend/`](examples/demo-new-grad-backend/applications/demo-cloud-backend/)

## Is This For You?

**A good fit**

- You are applying to Korean companies and already use a coding agent (Claude Code, Codex, or OpenCode).
- You have a resume or portfolio, and the hard part is turning it into 자기소개서 sentences you can defend.
- You want the cover letter reviewed before submission, not written faster.

**Not a fit yet**

- You cannot run local Node.js tools. The CLI, TUI, and local dashboard require Node.js `18.17`+; AI drafting still runs in your existing coding agent.
- You want automated mass applying. This toolkit refuses to submit, log in, send email, or bypass CAPTCHA by design.
- You want the agent to fill gaps in your experience. It stops and asks instead of inventing.

## Features

- Resume evidence intake: structure user-provided career facts into reusable `resume.md` evidence.
- JD analysis: extract role requirements, evaluation criteria, keywords, gaps, and risks from Korean job posts.
- Company-values analysis: use optional mission, culture, values, or talent-profile material for positioning.
- Korean cover-letter drafting: write answers grounded in `resume.md`, JD analysis, and optional company context.
- Career-type playbooks: new graduates and experienced hires are drafted and reviewed against different criteria, including 이직 사유 and short-tenure handling for experienced candidates.
- HR review: check exaggeration, unsupported claims, company-name residue, wrong sub-role targeting, and pre-submission blockers.
- Interview preparation: generate follow-up questions and evidence-backed answer points for interview defense.
- Application packaging: create one `applications/<company-role>/` package with a manual checklist.
- Job operations: paste multiple posting URLs (one per line), import CSV or JD text, and keep active lists clean by removing jobs after their Seoul-time deadline.
- Resumable validation: separate template structure checks from readiness checks tied to resume, JD, question, answer, evidence, final-text, and HR-review hashes.
- Recruitment tracking: record user-confirmed submissions, arbitrary stages, Seoul-time schedules, interview debriefs, and confirmed outcomes.
- Shared surfaces: operate the same local data and validation through the agent, CLI, keyboard TUI, or a `127.0.0.1` web dashboard.
- Job-source tools: normalize a user-supplied public HTTPS job page, with dedicated extraction for JobKorea, Linkareer, SK Careers, and LG Careers. Automated discovery remains outside the product scope.
- No credentials: nothing here needs an API key, access token, or approved API access.

## Documentation

| Document | Purpose |
| --- | --- |
| [Korean README](docs/README-ko.md) | Korean detailed guide and documentation hub |
| [Quickstart](docs/quickstart.md) | Minimal local workflow for one application package |
| [npm Install](docs/npm-install.md) | npm-based skill and agent installation |
| [Platform Support](docs/platform-support.md) | Windows PowerShell, Ubuntu/Linux, and macOS support |
| [Safety Policy](docs/safety.md) | Allowed actions, disallowed actions, and blocker examples |
| [Release Checklist](docs/release-checklist.md) | Pre-release validation checklist |
| [Competitive v1 Roadmap](docs/competitive-v1-roadmap.md) | Korea-only product roadmap |
| [Job Source Integrations](docs/integrations/job-sources.md) | Manual URL intake support and automated discovery status |
| [Integrated Workflow](docs/integrated-workflow.md) | Jobs, readiness, tracking, TUI, dashboard, and agent-request commands |
| [Agent Evaluation](docs/agent-evaluation.md) | Fictional new-grad, experienced, and non-technical verification scenarios |

## Requirements

Use Node.js `18.17` or newer.

```bash
node --version
npm --version
```

The local tools support:

- Windows PowerShell
- Ubuntu/Linux shell
- macOS shell

To use this repository directly:

```bash
git clone https://github.com/kyoungbinkim/give-me-job.git
cd give-me-job
npm test
```

## Installation

The simplest install path is `npx`:

```bash
npx give-me-job@latest install
```

Keep the `npx give-me-job@latest` prefix for later commands. If you want the
shorter `give-me-job` command, install the CLI globally as shown below.

This installs the eight domain skills plus the `give-me-job` orchestrator agent for supported coding agents in your user profile. The support bundle includes `agent.md`, `tools/`, `templates/`, and validation fixtures. Claude Code also gets tool-shaped skills such as `give-me-job-fetch-jobs`; OpenCode also gets custom tool definitions under its tools directory.

You can also install the CLI globally:

```bash
npm i -g give-me-job
give-me-job install
```

Claude Code users can add the domain skills as a plugin instead, without npm:

```txt
/plugin marketplace add kyoungbinkim/give-me-job
/plugin install give-me-job
```

The plugin route installs the domain skills only. The npm installer additionally
writes the `give-me-job` orchestrator agent, the tool-shaped workflow skills,
and the support bundle (`agent.md`, `tools/`, `templates/`, fixtures), which the
full workflow needs. Use `npx give-me-job@latest install` for the complete setup.

Without `--target`, the installer asks which AI agent to install to. Use the arrow keys to choose `codex`, `claude`, `opencode`, or `all`.

Install every supported target:

```bash
give-me-job install --target all
```

Install one target:

```bash
give-me-job install --target codex
give-me-job install --target opencode
give-me-job install --target claude-code
```

Install into the current project instead of your user profile:

```bash
give-me-job install --scope project --target all
```

Preview changes before writing files:

```bash
give-me-job install --dry-run
```

By default, the installer refuses to overwrite files that differ from the packaged version. Use `--force` only when you intentionally want to replace existing installed files. The installer writes timestamped `.bak-*` backups first.

```bash
give-me-job install --target codex --force
```

Check the installation:

```bash
gi
````
