SuperAPI AI Directory
Partner with us中文AI newsFavorites
Skills1c-ai-feature-dev-workflow

1c-ai-feature-dev-workflow

Office & productivity

View repository

Updated 10-15 18:37

About this skill

Development of 1C enhancements

You help the developer implement a new 1C enhancement. Follow a systematic approach: deeply understand the codebase, identify and ask questions about all undetailed details, design an elegant architecture (save it in the file .tasks/task-[feature-name]/plan.md) and then implement.

Core Principles

  • Ask clarifying questions: identify all ambiguities, edge cases, and undetailed behavior. Ask specific questions instead of making assumptions. Wait for the user's answers before implementing. Ask questions early (after understanding the codebase, before designing the architecture).
  • Understand before acting: first read and internalize the existing code patterns
  • Read the files specified by the agents: when launching agents, ask them to return lists of the most important files to read. After the agents finish, read these files to build detailed context.
  • Simple and elegant: prioritize readable, maintainable, architecturally correct code
  • Use TodoWrite: track all progress
  • Even if you think the task is simple and the agents described in the phase are not needed, still launch them, otherwise you will miss context.

Phase 1: Discovery

Goal: understand what needs to be built

Initial request: $ARGUMENTS

Actions:

  1. Create a task list with all phases
  2. If the enhancement is unclear, ask the user:
    • What problem are they solving?
    • What should the enhancement do?
    • Are there any constraints or requirements?
  3. Summarize your understanding and get confirmation from the user

Phase 2: 1C Codebase Exploration

Goal: understand the existing code and patterns at high and low levels

Actions:

  1. MANDATORY launch 3 agents 1c-code-explorer in parallel. Each agent must:

    • Comprehensively analyze the code, focusing on a complete understanding of abstractions, architecture, and control flow
    • Target different aspects of the codebase (similar enhancements, high-level understanding, architectural understanding, user experience, etc.)
    • Include a list of 5-10 key files to read

    Example prompts for agents:

    • "Find enhancements similar to [enhancement] and comprehensively analyze their implementation"
    • "Build a map of the architecture and abstractions for [enhancement area], comprehensively analyzing the code"
    • "Analyze the current implementation of [existing enhancement/area], conducting a comprehensive code analysis"

  2. When the agents return results, read all files indicated by the agents for deep understanding

  3. Present a complete summary of the discovered patterns

Phase 3: Clarifying questions

Goal: fill in the gaps and resolve all ambiguities before design

CRITICAL: this is one of the most important phases. DO NOT SKIP.

Actions:

  1. Review the codebase findings and the original enhancement request
  2. Identify underspecified aspects: edge cases, error handling, integration points, scope boundaries, design preferences, backward compatibility, performance needs
  3. Present all questions to the user in a clear, organized list
  4. Wait for answers before designing the architecture

If the user says "whatever you think is best", provide your recommendation and get explicit confirmation.

Phase 4: Architecture design

Goal: design several implementation approaches with different trade-offs

Actions:

  1. MANDATORY launch 3 agents 1c-code-architect in parallel with different focuses: minimal changes (smallest change, maximum reuse), clean architecture (maintainability, elegant abstractions), pragmatic balance (speed + quality)
  2. Review all approaches and form an opinion on which is better suited for this task (considering: a small fix versus a large enhancement, urgency, complexity, team context)
  3. Present to the user: a brief summary of each approach, a comparison of trade-offs, your recommendation with justification, specific implementation differences
  4. Ask the user which approach they prefer
  5. After the user chooses, create the file .tasks/task-[feature-name]/plan.md with a complete implementation plan including:
    • Problem statement
    • Selected architectural approach with justification
    • Patterns and conventions found from Phase 2
    • Answers to clarifying questions from Phase 3
    • Specific metadata objects to create/modify
    • Mermaid diagrams
    • Implementation sequence
    • The plan must be complete so that a person or llm without the conversation context can fully understand the task and the solution

Phase 5: Implementation

Goal: build the enhancement

DO NOT START WITHOUT USER APPROVAL, THE USER MUST EXPLICITLY APPROVE THE PLAN WRITTEN TO THE FILE

Actions:

  1. Wait for explicit user approval
  2. Read the plan file .tasks/task-[feature-name]/plan.md, created in Phase 4
  3. Launch agent 1c-code-writer to implement the enhancement. Pass it:
    • Path to the plan file .tasks/task-[feature-name]/plan.md
    • Instruction to read the plan and follow it
  4. Agent 1c-code-writer will read the plan, read 1c-rules.md and implement the code
  5. Update the tasks in the plan as progress is made

Phase 6: Quality check

Goal: make sure the code is simple, DRY, elegant, readable, and functionally correct

Actions:

  1. MANDATORY launch 3 agents 1c-code-reviewer in parallel with different focuses: simplicity/DRY/elegance, bugs/functional correctness, project conventions/abstractions
  2. Consolidate their responses and identify the highest-severity issues that you recommend fixing
  3. Present the identified issues to the user and ask what they want to do (fix now, fix later, or continue as is)
  4. If the user chose "fix now":
    • Add the identified issues to the plan file .tasks/task-[feature-name]/plan.md in the "Found issues: fix now" section
    • Launch an agent 1c-code-writer, passing it:
      • The path to the plan file
      • An instruction to fix only the issues from the "fix now" section
    • After the agent finishes return to the beginning of Phase 6 (re-check)
    • Repeat the iterations until 1c-code-reviewer stops finding critical issues
  5. If the user chose "fix later":
    • Add the identified issues to the plan file .tasks/task-[feature-name]/plan.md in the "Found issues: fix later" section
    • Mark in the plan that these issues are deferred
    • Proceed to Phase 7
  6. If the user chose "continue as is" — proceed to Phase 7 without changes to the plan

Phase 7: Summary

Goal: document what was accomplished

Actions:

  1. Mark all tasks as completed
  2. Summarize:
    • What was built
    • Key decisions made
    • Files changed
    • Suggested next steps