Agent skill

Start

by jlifeng in jlifeng/JobPilot

“Start Session”

— description from SKILL.md by jlifeng
Apache-2.0Auto-check passedAgent Workflows

Install Start

skills CLI
$ npx skills add jlifeng/JobPilot --skill start -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jlifeng/JobPilot start --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jlifeng/JobPilot.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/start .claude/skills/start && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
start
GitHub stars
140
Token cost
~2.4k tokens
SKILL.md length
1,030 words
Files
1
Skills in repo
5
Repo updated
First seen
Licence
Apache-2.0

At a glance

  • Works in 7 steps: Understand Development Workflow → Get Current Context → Read Guidelines Index → …
  • SKILL.md covers Operation Types, Initialization [AI], Task Classification and Question / Trivial Fix, plus 6 more sections
  • Calls python3

About this skill

Start is a skill in jlifeng/JobPilot (140 stars). Its SKILL.md is about 2.4k tokens. Licence: Apache-2.0.

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Understand Development Workflow
  2. Get Current Context
  3. Read Guidelines Index
  4. Report and Ask
  5. Establish Requirements
  6. Prepare for Implementation (shared)
  7. Execute (shared)

What it can do on your machine

Read from SKILL.md and the folder at commit fdb47e2. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Start loads about 2.4k tokens when it runs. Until then it costs about 5 tokens; SKILL.md has 1,030 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~5
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from jlifeng/JobPilot at commit fdb47e2, republished under its Apache-2.0 licence (© jlifeng). 1,030 words, ~2,372 tokens.

Download SKILL.mdSave it as .claude/skills/start/SKILL.md (or your agent's skills folder).
name
start
description
Start Session

Start Session

Initialize your AI development session and begin working on tasks.


Operation Types

MarkerMeaningExecutor
[AI]Bash scripts or tool calls executed by AIYou (AI)
[USER]Skills executed by userUser

Initialization [AI]

Step 1: Understand Development Workflow

First, read the workflow guide to understand the development process:

bash
cat .trellis/workflow.md

Follow the instructions in workflow.md - it contains:

  • Core principles (Read Before Write, Follow Standards, etc.)
  • File system structure
  • Development process
  • Best practices
Step 2: Get Current Context
bash
python3 ./.trellis/scripts/get_context.py

This shows: developer identity, git status, current task (if any), active tasks.

Step 3: Read Guidelines Index
bash
cat .trellis/spec/frontend/index.md  # Frontend guidelines
cat .trellis/spec/backend/index.md   # Backend guidelines
cat .trellis/spec/guides/index.md    # Thinking guides

Important: The index files are navigation — they list the actual guideline files (e.g., error-handling.md, conventions.md, mock-strategies.md). At this step, just read the indexes to understand what's available. When you start actual development, you MUST go back and read the specific guideline files relevant to your task, as listed in the index's Pre-Development Checklist.

Step 4: Report and Ask

Report what you learned and ask: "What would you like to work on?"


Task Classification

When user describes a task, classify it:

TypeCriteriaWorkflow
QuestionUser asks about code, architecture, or how something worksAnswer directly
Trivial FixTypo fix, comment update, single-line change, < 5 minutesDirect Edit
Simple TaskClear goal, 1-2 files, well-defined scopeQuick confirm → Task Workflow
Complex TaskVague goal, multiple files, architectural decisionsBrainstorm → Task Workflow
Decision Rule

If in doubt, use Brainstorm + Task Workflow.

Task Workflow ensures code-specs are injected to the right context, resulting in higher quality code. The overhead is minimal, but the benefit is significant.

Subtask Decomposition: If brainstorm reveals multiple independent work items, consider creating subtasks using --parent flag or add-subtask command. See the brainstorm skill's Step 8 for details.


Question / Trivial Fix

For questions or trivial fixes, work directly:

  1. Answer question or make the fix
  2. If code was changed, remind user to run $finish-work

Simple Task

For simple, well-defined tasks:

  1. Quick confirm: "I understand you want to [goal]. Shall I proceed?"
  2. If no, clarify and confirm again
  3. If yes: execute ALL steps below without stopping. Do NOT ask for additional confirmation between steps.
    • Create task directory (Phase 1 Path B, Step 2)
    • Write PRD (Step 3)
    • Research codebase (Phase 2, Step 5)
    • Configure context (Step 6)
    • Activate task (Step 7)
    • Implement (Phase 3, Step 8)
    • Check quality (Step 9)
    • Complete (Step 10)

Complex Task - Brainstorm First

For complex or vague tasks, automatically start the brainstorm process — do NOT skip directly to implementation.

See $brainstorm for the full process. Summary:

  1. Acknowledge and classify - State your understanding
  2. Create task directory - Track evolving requirements in prd.md
  3. Ask questions one at a time - Update PRD after each answer
  4. Propose approaches - For architectural decisions
  5. Confirm final requirements - Get explicit approval
  6. Proceed to Task Workflow - With clear requirements in PRD

Task Workflow (Development Tasks)

Why this workflow?

  • Run a dedicated research pass before coding
  • Configure specs in jsonl context files
  • Implement using injected context
  • Verify with a separate check pass
  • Result: Code that follows project conventions automatically
Overview: Two Entry Points
From Brainstorm (Complex Task):
  PRD confirmed → Research → Configure Context → Activate → Implement → Check → Complete

From Simple Task:
  Confirm → Create Task → Write PRD → Research → Configure Context → Activate → Implement → Check → Complete

Key principle: Research happens AFTER requirements are clear (PRD exists).


Phase 1: Establish Requirements
Path A: From Brainstorm (skip to Phase 2)

PRD and task directory already exist from brainstorm. Skip directly to Phase 2.

Path B: From Simple Task

Step 1: Confirm Understanding [AI]

Quick confirm:

  • What is the goal?
  • What type of development? (frontend / backend / fullstack)
  • Any specific requirements or constraints?

If unclear, ask clarifying questions.

Step 2: Create Task Directory [AI]

bash
TASK_DIR=$(python3 ./.trellis/scripts/task.py create "<title>" --slug <name>)

Step 3: Write PRD [AI]

Create prd.md in the task directory with:

markdown
# <Task Title>

## Goal
<What we're trying to achieve>

## Requirements
- <Requirement 1>
- <Requirement 2>

## Acceptance Criteria
- [ ] <Criterion 1>
- [ ] <Criterion 2>

## Technical Notes
<Any technical decisions or constraints>

Show full SKILL.md (433 more words)Show less
Phase 2: Prepare for Implementation (shared)

Both paths converge here. PRD and task directory must exist before proceeding.

Step 4: Code-Spec Depth Check [AI]

If the task touches infra or cross-layer contracts, do not start implementation until code-spec depth is defined.

Trigger this requirement when the change includes any of:

  • New or changed command/API signatures
  • Database schema or migration changes
  • Infra integrations (storage, queue, cache, secrets, env contracts)
  • Cross-layer payload transformations

Must-have before proceeding:

  • Target code-spec files to update are identified
  • Concrete contract is defined (signature, fields, env keys)
  • Validation and error matrix is defined
  • At least one Good/Base/Bad case is defined

Step 5: Research the Codebase [AI]

Based on the confirmed PRD, run a focused research pass and produce:

  1. Relevant spec files in .trellis/spec/
  2. Existing code patterns to follow (2-3 examples)
  3. Files that will likely need modification

Use this output format:

markdown
## Relevant Specs
- <path>: <why it's relevant>

## Code Patterns Found
- <pattern>: <example file path>

## Files to Modify
- <path>: <what change>

Step 6: Configure Context [AI]

Initialize default context:

bash
python3 ./.trellis/scripts/task.py init-context "$TASK_DIR" <type>
# type: backend | frontend | fullstack

Add specs found in your research pass:

bash
# For each relevant spec and code pattern:
python3 ./.trellis/scripts/task.py add-context "$TASK_DIR" implement "<path>" "<reason>"
python3 ./.trellis/scripts/task.py add-context "$TASK_DIR" check "<path>" "<reason>"

Step 7: Activate Task [AI]

bash
python3 ./.trellis/scripts/task.py start "$TASK_DIR"

This sets .current-task so hooks can inject context.


Phase 3: Execute (shared)

Step 8: Implement [AI]

Implement the task described in prd.md.

  • Follow all specs injected into implement context
  • Keep changes scoped to requirements
  • Run lint and typecheck before finishing

Step 9: Check Quality [AI]

Run a quality pass against check context:

  • Review all code changes against the specs
  • Fix issues directly
  • Ensure lint and typecheck pass

Step 10: Complete [AI]

  1. Verify lint and typecheck pass
  2. Report what was implemented
  3. Remind user to:
    • Test the changes
    • Commit when ready
    • Run $record-session to record this session

Continuing Existing Task

If get_context.py shows a current task:

  1. Read the task's prd.md to understand the goal
  2. Check task.json for current status and phase
  3. Ask user: "Continue working on <task-name>?"

If yes, resume from the appropriate step (usually Step 7 or 8).


Skills Reference

User Skills [USER]
SkillWhen to Use
$startBegin a session (this skill)
$finish-workBefore committing changes
$record-sessionAfter completing a task
AI Scripts [AI]
ScriptPurpose
python3 ./.trellis/scripts/get_context.pyGet session context
python3 ./.trellis/scripts/task.py createCreate task directory
python3 ./.trellis/scripts/task.py init-contextInitialize jsonl files
python3 ./.trellis/scripts/task.py add-contextAdd spec to jsonl
python3 ./.trellis/scripts/task.py startSet current task
python3 ./.trellis/scripts/task.py finishClear current task
python3 ./.trellis/scripts/task.py archiveArchive completed task
Workflow Phases [AI]
PhasePurposeContext Source
researchAnalyze codebasedirect repo inspection
implementWrite codeimplement.jsonl
checkReview & fixcheck.jsonl
debugFix specific issuesdebug.jsonl

Key Principle

Code-spec context is injected, not remembered.

The Task Workflow ensures agents receive relevant code-spec context automatically. This is more reliable than hoping the AI "remembers" conventions.

© jlifeng, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/start of jlifeng/JobPilot.

Open the folder on GitHubat commit fdb47e2

Compare with similar skills

Start next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Start compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Start this skilljlifeng/JobPilot140—~2.4kAutomated safety check: PassApache-2.0
Brainstormingxpinjection/test-driven-spring-boot11254 repos~2.6kAutomated safety check: PassMIT
LLM Councilgcpdev/llm-council-skill4611 repos~1kAutomated safety check: NotesMIT
Typesafe AIOpenAgentsInc/openagents4559 repos~2.5kAutomated safety check: PassMIT
Yao Meta Skillyaojingang/yao-meta-skill2.7k—~768Automated safety check: PassMIT
Trellis StartROYIANS/foliq-print-template-designer1356 repos~646Automated safety check: PassMIT

Similar skills

  • Brainstorming

    xpinjection/test-driven-spring-boot

    You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior.

    112 GitHub starsUsed in 54 repos~2.6k tokens
    Agent WorkflowsAuto-check passed
  • LLM Council

    gcpdev/llm-council-skill

    Multi-LLM collaborative brainstorming and planning. An agent skill from gcpdev/llm-council-skill.

    461 GitHub starsUsed in 1 repo~1k tokens
    Agent WorkflowsAuto-check: notes
  • Typesafe AI

    OpenAgentsInc/openagents

    Build AI-powered software with TypeSafe: small units of AI intelligence you can use like programming primitives.

    455 GitHub starsUsed in 9 repos~2.5k tokens
    Agent WorkflowsAuto-check passed
  • Yao Meta Skill

    yaojingang/yao-meta-skill

    Create, improve, or evaluate an existing skill from workflows, prompts, SOPs, scripts.

    2.7k GitHub stars~768 tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed
  • Trellis Start

    ROYIANS/foliq-print-template-designer

    Initializes an AI development session by reading workflow guides, developer identity, git status, active tasks, and project guidelines from .trellis/.

    135 GitHub starsUsed in 6 repos~646 tokens
    Agent WorkflowsAuto-check passed
  • Brainstorming Before Building

    jnMetaCode/superpowers-zh

    Turns a rough idea into an approved design before any code is written, sorting the request into spike, bounded or architectural and enforcing an approval gate.

    8.3k GitHub stars~1.8k tokensUpdated 4 days ago
    Agent WorkflowsAuto-check passed

More from jlifeng/JobPilot

  • Brainstorm

    jlifeng/JobPilot

    Brainstorm - Requirements Discovery (AI Coding Enhanced). An agent skill from jlifeng/JobPilot.

    140 GitHub stars~3.1k tokensUpdated 8 days ago
    Auto-check passed
  • Update Spec

    jlifeng/JobPilot

    Update Code-Spec - Capture Executable Contracts. An agent skill from jlifeng/JobPilot.

    140 GitHub stars~2.4k tokensUpdated 8 days ago
    Auto-check passed
  • Break Loop

    jlifeng/JobPilot

    Break the Loop - Deep Bug Analysis

    140 GitHub stars~1.1k tokensUpdated 8 days ago
    Auto-check passed
  • Finish Work

    jlifeng/JobPilot

    Finish Work - Pre-Commit Checklist

    140 GitHub stars~1.1k tokensUpdated 8 days ago
    Auto-check passed

Categories

Questions about Start

How do I install Start in Claude Code?

Run `npx skills add jlifeng/JobPilot --skill start -a claude-code`. Or copy the skill folder (.agents/skills/start in jlifeng/JobPilot) into .claude/skills/start in your project. Claude Code loads it when a task matches its description.

How do I install Start in Codex?

Run `npx skills add jlifeng/JobPilot --skill start -a codex`. Or copy the skill folder (.agents/skills/start in jlifeng/JobPilot) into .agents/skills/start in your project. Codex loads it when a task matches its description.

Can I use Start in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jlifeng/JobPilot --skill start -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/start, .gemini/skills/start, .github/skills/start and .opencode/skills/start in your project.

What does Start need to run?

Going by SKILL.md and its folder, Start needs the command-line tools its instructions call (python3).

Does Start access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Start safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Start use?

Start is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Start use?

About 2.4k tokens (SKILL.md is roughly 9.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Start?

Skills that share tags, products or a category with Start: Brainstorming (xpinjection/test-driven-spring-boot, 112 stars), LLM Council (gcpdev/llm-council-skill, 461 stars), Typesafe AI (OpenAgentsInc/openagents, 455 stars) and Yao Meta Skill (yaojingang/yao-meta-skill, 2.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Start?

jlifeng (a GitHub user) maintains it in jlifeng/JobPilot, which has 140 GitHub stars. The repository holds 5 skills in this directory. The repository was last updated on September 30, 2026.

Source: jlifeng/JobPilot on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.