Project Scaffolding Skill

Comprehensive guide to project type detection, template selection, post-scaffolding setup, Harness integration, and testing strategies.

Project Type Detection Matrix

How to Detect Project Type

Detection Priority:

• Look for language-specific files in root

• Check build system presence

• Examine package/dependency files

• Analyze configuration files

• Review existing CI/CD setup

Type Identification Checklist

Python Project: ✓ setup.py, pyproject.toml, or requirements.txt ✓ .python-version file ✓ Pipfile (Pipenv) ✓ poetry.lock (Poetry)

Node.js/JavaScript: ✓ package.json exists ✓ node_modules/ directory ✓ .npmrc or .yarnrc ✓ yarn.lock or package-lock.json

Java/JVM: ✓ pom.xml (Maven) or build.gradle (Gradle) ✓ src/main/java structure ✓ .java files present

Go: ✓ go.mod file ✓ *.go source files ✓ go.sum dependencies file

Rust: ✓ Cargo.toml ✓ src/ directory ✓ Cargo.lock

C#/.NET: ✓ *.csproj or *.sln files ✓ appsettings.json ✓ global.json

TypeScript: ✓ tsconfig.json ✓ *.ts or *.tsx files ✓ package.json with typescript dependency

Kubernetes/DevOps: ✓ Dockerfile ✓ docker-compose.yml ✓ k8s/ or helm/ directory ✓ Helmfile

Infrastructure as Code: ✓ *.tf files (Terraform) ✓ bicep/ directory (Azure Bicep) ✓ cloudformation.yaml (AWS CloudFormation)

Project Type Recommendations Matrix

1. Python Projects

Best Templates:

• Cookiecutter - Standard Python projects, packages

• Copier - Complex projects with versioning needs

• Poetry - Modern Python packaging

Template Structure:

{project_name}/ ├── {project_name}/ # Main package │ ├── init.py │ ├── main.py │ └── config.py ├── tests/ # Test directory │ ├── init.py │ ├── conftest.py # pytest fixtures │ └── test_main.py ├── docs/ # Documentation │ ├── conf.py # Sphinx config │ ├── index.rst │ └── api.rst ├── .gitignore ├── README.md ├── LICENSE ├── requirements.txt # Or pyproject.toml ├── setup.py # Or tool.poetry in pyproject.toml ├── pytest.ini ├── tox.ini # Multi-environment testing └── Dockerfile

Key Variables:

project_name: str # Package name (lowercase, underscores) author_name: str # Author name author_email: str # Author email python_version: str # Target version (3.9, 3.10, 3.11, 3.12) use_poetry: bool # Use Poetry for dependency management use_pytest: bool # Use pytest (default: true) use_docker: bool # Include Dockerfile include_cli: bool # Include Click CLI framework

Post-Scaffolding:

cd {project_name} python -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate pip install -r requirements.txt pytest tests/ # Verify test setup

2. Node.js/JavaScript Projects

Best Templates:

• Cookiecutter - Standard Node projects

• Copier - Full-stack applications

Template Structure:

{project_name}/ ├── src/ │ ├── index.js │ ├── config.js │ └── utils/ ├── tests/ │ ├── unit/ │ ├── integration/ │ └── fixtures/ ├── public/ # Static assets ├── docs/ ├── .env.example # Environment template ├── .eslintrc.json # ESLint config ├── .prettierrc.json # Code formatting ├── jest.config.js # Jest testing config ├── tsconfig.json # If using TypeScript ├── package.json ├── package-lock.json # Or yarn.lock / pnpm-lock.yaml ├── Dockerfile ├── docker-compose.yml ├── .gitignore ├── README.md └── LICENSE

Key Variables:

project_name: str # Project name author_name: str # Author use_typescript: bool # TypeScript support use_eslint: bool # ESLint (default: true) use_prettier: bool # Code formatter use_jest: bool # Jest testing use_docker: bool # Docker support use_express: bool # Express.js framework package_manager: str # npm, yarn, pnpm

Post-Scaffolding:

cd {project_name} npm install # or yarn / pnpm install npm run lint # Check linting npm run test # Run tests npm run dev # Start development server

3. Java/JVM Projects

Best Templates:

• Maven Archetypes - Standard Java projects

• Gradle Template - Gradle-based projects

Template Structure (Maven):

{project_name}/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/company/{project_name}/ │ │ │ ├── App.java │ │ │ └── service/ │ │ └── resources/ │ │ └── application.properties │ └── test/ │ ├── java/ │ │ └── com/company/{project_name}/ │ │ └── AppTest.java │ └── resources/ ├── docs/ ├── pom.xml # Maven configuration ├── README.md ├── Dockerfile └── .gitignore

Key Variables:

groupId: str # Maven group ID (e.g., com.company) artifactId: str # Maven artifact ID package: str # Java package name java_version: str # JDK version (11, 17, 21) spring_boot_version: str # If using Spring Boot build_tool: str # maven or gradle

Post-Scaffolding:

cd {project_name} mvn clean compile # Compile project mvn test # Run tests mvn spring-boot:run # If using Spring Boot

4. TypeScript Projects

Best Templates:

• ts-node - CLI tools and scripts

• Next.js - Full-stack web applications

• NestJS - Backend APIs

Template Structure:

{project_name}/ ├── src/ │ ├── index.ts │ ├── types/ │ │ └── index.ts │ ├── services/ │ ├── controllers/ # If REST API │ └── utils/ ├── tests/ │ ├── unit/ │ └── integration/ ├── dist/ # Compiled JavaScript (output) ├── tsconfig.json # TypeScript config ├── jest.config.js # Jest testing ├── .eslintrc.json # ESLint ├── package.json ├── Dockerfile ├── README.md └── .gitignore

Key Variables:

project_name: str typescript_version: str # Exact version or latest jest_enabled: bool # Testing framework eslint_enabled: bool # Linting strict_mode: bool # tsconfig strict target: str # Compilation target (ES2020, etc.) module: str # Module system (ESNext, CommonJS)

Post-Scaffolding:

cd {project_name} npm install npm run build # Compile TypeScript npm test # Run tests npm start # Run compiled code

5. Go Projects

Best Templates:

• Go Project Layout - Standard Go project structure

• Cobra CLI - CLI applications

Template Structure:

{project_name}/ ├── cmd/ │ ├── cli/ │ │ └── main.go # Application entry point │ └── server/ # If server application │ └── main.go ├── internal/ # Private packages │ ├── config/ │ ├── handler/ │ └── service/ ├── pkg/ # Public packages │ └── {package_name}/ ├── api/ # API definitions ├── test/ ├── docs/ ├── Makefile # Build automation ├── go.mod # Module definition ├── go.sum # Checksums ├── Dockerfile ├── .gitignore ├── README.md └── LICENSE

Key Variables:

project_name: str # Go module name (github.com/user/project) author_name: str go_version: str # Minimum Go version (1.19, 1.20, 1.21) use_cobra: bool # CLI framework use_gin: bool # Web framework (if server) use_gorm: bool # ORM (if database needed)

Post-Scaffolding:

cd {project_name} go mod download # Download dependencies go build ./cmd/cli # Build application go test ./... # Run tests ./cli --help # Test CLI

6. Kubernetes/DevOps Projects

Best Templates:

• Helm Chart - Kubernetes deployments

• Kustomize - Kubernetes customization

• Copier - Multi-environment setups

Template Structure:

{project_name}/ ├── helm/ │ └── {release_name}/ │ ├── Chart.yaml │ ├── values.yaml │ ├── values-dev.yaml │ ├── values-prod.yaml │ └── templates/ │ ├── deployment.yaml │ ├── service.yaml │ ├── configmap.yaml │ └── ingress.yaml ├── k8s/ │ ├── base/ │ ├── dev/ │ └── prod/ ├── kustomization.yaml ├── docker-compose.yml # For local development ├── Dockerfile ├── .dockerignore ├── docs/ ├── README.md └── .gitignore

Key Variables:

project_name: str # Application name image_registry: str # Docker registry image_name: str # Docker image name replicas_dev: int # Dev environment replicas replicas_prod: int # Prod environment replicas namespace: str # Kubernetes namespace enable_ingress: bool enable_monitoring: bool # Prometheus/monitoring

Post-Scaffolding:

cd {project_name} docker build -t {image}:latest . helm lint helm/{release} helm template helm/{release} -f values-dev.yaml kubectl apply -f k8s/dev/ # Deploy to dev

7. Infrastructure as Code (Terraform)

Best Templates:

• Terraform Module - Reusable infrastructure components

• Terraform Project - Full environment setup

Template Structure:

{project_name}/ ├── main.tf # Main configuration ├── variables.tf # Input variables ├── outputs.tf # Output values ├── terraform.tfvars # Variable values ├── locals.tf # Local values ├── vpc.tf # VPC configuration ├── security.tf # Security groups ├── iam.tf # IAM roles/policies ├── modules/ │ ├── vpc/ │ ├── compute/ │ └── database/ ├── environments/ │ ├── dev/ │ │ └── terraform.tfvars │ ├── staging/ │ └── prod/ ├── docs/ ├── .gitignore ├── README.md ├── versions.tf # Terraform version constraints └── backend.tf # State backend config

Key Variables:

project_name: str # Project identifier aws_region: str # AWS region environment: str # dev, staging, prod terraform_version: str # Minimum version

Post-Scaffolding:

cd environments/dev terraform init # Initialize backend terraform plan # Preview changes terraform apply # Apply configuration terraform output # View outputs

Post-Scaffolding Checklist

Universal Tasks (All Projects)

• Review generated files and structure

• Verify .gitignore is appropriate

• Update README.md with project-specific info

• Add LICENSE file (if not included)

• Initialize Git repository

• Create initial commit

• Add remote repository

• Verify dependency installation

• Run basic tests to confirm setup works

• Document build/run commands

• Set up CI/CD configuration

Language-Specific Tasks

Python:

• Verify virtual environment works

• Test package imports

• Check pytest configuration

• Verify linting (flake8/pylint) setup

• Test documentation build (if Sphinx)

• Verify type hints (if mypy configured)

Node.js:

• Verify npm/yarn/pnpm setup

• Test linting and formatting

• Verify test framework (Jest/Mocha)

• Check TypeScript compilation

• Verify build output directory

• Test hot reload (if dev server)

Java:

• Verify Maven/Gradle build

• Test unit tests run successfully

• Verify IDE integration

• Check dependency tree

• Verify JAR/WAR packaging

Go:

• Verify go mod download

• Test build command

• Verify all tests pass

• Check linting (golangci-lint)

• Verify binary execution

Docker Tasks

• Build Docker image

• Test image runs locally

• Verify volumes/ports are correct

• Document docker run command

• Add Docker Compose if multi-container

• Set up .dockerignore

Harness Integration Patterns

Pattern 1: Basic CI Pipeline

For: Single service, simple build and push

harness/build-pipeline.yaml

pipeline: name: Build and Push identifier: build_push stages: - stage: name: Build Docker type: CI spec: codebase: repoName: {project_name} branch: main build: type: Docker spec: dockerfile: Dockerfile registryConnector: <+input.docker_connector> imageName: <+input.image_name> imageTag: <+codebase.commitSha>

Pattern 2: Build, Test, and Deploy

For: Multi-stage pipeline with testing

pipeline: name: Build Test Deploy identifier: build_test_deploy stages: - stage: name: Build type: CI spec: build: type: Docker spec: dockerfile: Dockerfile

- stage:
    name: Test
    type: CI
    depends_on:
      - Build
    spec:
      steps:
        - step:
            type: Run
            spec:
              image: <+artifact.image>
              script: npm test

- stage:
    name: Deploy Dev
    type: Deployment
    depends_on:
      - Test
    spec:
      service:
        serviceRef: <+input.service>
      environment:
        environmentRef: dev

Pattern 3: Multi-Environment Deployment

For: Dev → Staging → Production with approvals

stages:

• stage: name: Deploy Dev type: Deployment spec: environment: dev infrastructure: dev-k8s-cluster

• stage: name: Deploy Staging type: Deployment depends_on: - Deploy Dev spec: environment: staging infrastructure: staging-k8s-cluster

• stage: name: Approval for Production type: Approval depends_on: - Deploy Staging spec: approvers: - <+input.approver_group>

• stage: name: Deploy Production type: Deployment depends_on: - Approval for Production spec: environment: production infrastructure: prod-k8s-cluster

Pattern 4: GitOps with Harness

For: Managing manifests separately from source code

stages:

• stage: name: Build type: CI spec: build: type: Docker

• stage: name: Update Manifests type: CI spec: steps: - step: type: Run spec: script: | git clone <+input.manifest_repo> sed -i "s/IMAGE_TAG/<+artifact.imageTag>/g" k8s/deployment.yaml git commit && git push

• stage: name: Deploy via GitOps type: Deployment spec: gitOpsEnabled: true service: serviceRef: <+input.service> environment: environmentRef: <+input.environment>

Testing Recommendations by Project Type

Python Testing

Frameworks:

• pytest - Modern, flexible test framework

• unittest - Standard library

• nose2 - Plugin-based testing

Setup:

pip install pytest pytest-cov pytest-mock

Test Structure:

tests/ ├── conftest.py # Shared fixtures ├── unit/ │ ├── test_module.py │ └── test_service.py ├── integration/ │ └── test_api.py └── fixtures/ └── sample_data.py

Coverage Target: 80%+

Node.js Testing

Frameworks:

• Jest - All-in-one solution

• Mocha + Chai - Flexible combination

• Vitest - Fast alternative

Setup:

npm install --save-dev jest @testing-library/react

Test Structure:

tests/ ├── unit/ │ ├── utils.test.js │ └── helpers.test.js ├── integration/ │ └── api.test.js └── e2e/ └── user-flow.test.js

Coverage Target: 80%+

Java Testing

Frameworks:

• JUnit 5 - Modern testing framework

• Mockito - Mocking framework

• TestNG - Alternative to JUnit

Setup:

<dependency> <groupId>junit</groupId> <artifactId>junit-jupiter</artifactId> <scope>test</scope> </dependency>

Test Structure:

src/test/java/ └── com/company/project/ ├── ServiceTest.java ├── ControllerTest.java └── IntegrationTest.java

Coverage Target: 80%+

Go Testing

Testing Style:

• Standard Go testing package

• Table-driven tests

• Subtests

Setup:

go get github.com/stretchr/testify

Test Structure:

internal/ ├── service/ │ ├── service.go │ └── service_test.go └── handler/ ├── handler.go └── handler_test.go

Coverage Target: 80%+

Post-Scaffolding Setup Verification

Universal Verification Commands

Git setup

git init git add . git commit -m "Initial commit from template"

Dependency verification

{build-tool} list # List dependencies

Test verification

{build-tool} test # Run test suite

Build verification

{build-tool} build # Build project

Docker verification (if applicable)

docker build -t {image}:test . docker run {image}:test --version

Checklist Summary

ESSENTIAL:

• Project initialized and builds
• Dependencies installed
• Tests run and pass
• Documentation exists
• .gitignore configured
• Initial commit created

HARNESS INTEGRATION:

• Harness service created
• Pipeline template ready
• Environment configured
• Deployment target defined

QUALITY GATES:

• Linting passes
• Tests pass
• Code coverage >= 80%
• Documentation complete
• Security scan passes

Related Documentation

• Cookiecutter Documentation

• Copier Documentation

• Maven Archetypes

• Harness Delegate Setup

• Helm Charts

• Terraform Best Practices