# How Python-100-Days Covers Team Project Development: Agile, Git, and CI/CD

> Learn how Python-100-Days guides team project development with agile Scrum, Git workflows, code reviews, and CI/CD for production-ready collaborative software.

- Repository: [骆昊/Python-100-Days](https://github.com/jackfrued/Python-100-Days)
- Tags: deep-dive
- Published: 2026-02-24

---

**The Python-100-Days repository dedicates Days 91–100 to a comprehensive guide on team project development, covering agile Scrum methodologies, Git workflows, code review standards, and continuous integration pipelines to transform solo scripts into production-ready collaborative software.**

The transition from writing individual Python scripts to contributing in a professional team environment requires structured processes and tooling. The popular `jackfrued/Python-100-Days` repository addresses this gap in its final chapter, offering a practical roadmap for team project development that mirrors real-world software engineering practices. According to the source code analysis of `Day91-100/91.团队项目开发的问题和解决方案.md`, the guide walks readers through the complete lifecycle from team formation to deployment.

## Software Process Models and Agile Frameworks

The repository begins by contrasting traditional and modern development approaches. In `Day91-100/91.团队项目开发的问题和解决方案.md` (lines 996–1011), the guide explains the **waterfall model** and its inherent drawbacks, then introduces **agile Scrum** as the preferred methodology for team project development.

The documentation details specific Scrum roles that should be established:

- **Product Owner** – defines the product backlog and prioritizes features
- **Scrum Master** – facilitates the process and removes impediments  
- **Development Team** – the cross-functional group building the software

For ceremonies, the guide prescribes a standard Sprint cycle including Backlog grooming, Sprint planning, Daily stand-ups, Sprint Reviews, and Retrospectives (lines 996–1011).

## Team Formation and Coding Standards

Effective team project development starts with proper team structure. The guide suggests an optimal team size of **8–10 people** with clearly defined roles to minimize communication overhead (lines 1024–1032).

To maintain codebase integrity, the repository emphasizes strict **coding standards**:

- Use static analysis tools like `flake8` and `pylint` for automated style checking
- Enforce mandatory **code review** practices before any integration
- Document conventions in a [`CONTRIBUTING.md`](https://github.com/jackfrued/Python-100-Days/blob/main/CONTRIBUTING.md) file

These standards are referenced in lines 1037–1040 of the main documentation file.

## Git-Centric Collaboration Workflows

Version control forms the backbone of the collaborative workflow described in Python-100-Days. The guide provides a deep dive into Git implementation (lines 1064–1125), recommending **Git as the single source of truth** for all team project development.

The repository advocates for a structured branching strategy:

1. **Protected `main` branch** – Always reflects a deployable state; direct pushes are prohibited
2. **Feature branches** – Each task or user story gets an isolated branch (naming convention: `feature/123-short-description`)
3. **Pull Request workflow** – All changes require peer review and CI approval before merging
4. **Branch protection rules** – Require status checks to pass and enforce code owner reviews

The guide compares **GitHub-flow** (simpler, suitable for web applications) and **Git-flow** (robust, better for versioned software), providing visual diagrams in `Day91-100/res/git-flow.png` to illustrate these models.

## Issue-Driven Development and Defect Tracking

Python-100-Days promotes an **issue-driven workflow** where every feature or bug is tracked systematically. According to lines 1159–1189, the guide recommends defect-tracking platforms such as **Gitee**, **GitLab**, **ZenTao**, or **JIRA**.

A proper issue ticket should include specific fields:

- Clear reproduction steps for bugs
- Expected vs. actual behavior
- Environment details (Python version, OS)
- Traceability links to requirements

This creates full traceability from requirement → code → test → release, with issue IDs appearing directly in branch names (e.g., `feature/42-add-login`) and commit messages.

## Continuous Integration and Deployment

The repository stresses that **Continuous Integration (CI)** is essential for maintaining quality in team project development (lines 1195–1220). The guide mentions **Jenkins** and **Travis CI** as automation servers, explaining how CI pipelines can be triggered by Git hooks or webhooks to run the quality gates automatically.

For release management (lines 1225–1240), the documentation covers:

- Release planning and version tagging (`git tag v1.2.3`)
- Deployment strategies including packaging, Docker containers, or cloud services
- Automated artifact publishing to internal registries after CI passes

## Practical Implementation Examples

Below are copy-paste ready configurations that implement the practices described in the Python-100-Days guide.

### Initializing a Protected Repository

```bash

# Create repo and initial commit

git init
echo "# MyTeamProject" > README.md

git add README.md
git commit -m "Initial commit"

# Create and push the main branch

git branch -M main
git remote add origin git@github.com:MyOrg/MyTeamProject.git
git push -u origin main

# Protect the branch on GitHub/Gitee (via UI or API)

# – Require pull request reviews

# – Require CI status checks to pass

```

### Feature-Branch Workflow

```bash

# Start a new feature referencing issue #42

git checkout -b feature/42-add-login

# ... develop code ...

git add .
git commit -m "feat: add login endpoint (issue #42)"
git push -u origin feature/42-add-login

# Open a Pull Request on GitHub/Gitee → reviewers approve → CI passes → merge

```

### GitHub Actions CI Configuration

Create [`.github/workflows/ci.yml`](https://github.com/jackfrued/Python-100-Days/blob/main/.github/workflows/ci.yml) to enforce the quality gates:

```yaml
name: CI

on: [push, pull_request]

jobs:
  lint-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: "3.12"
      - name: Install dependencies
        run: |
          pip install -r requirements.txt
          pip install flake8 pylint pytest
      - name: Lint
        run: |
          flake8 src/
          pylint src/
      - name: Test
        run: pytest tests/

```

### Issue Template for Defect Tracking

Place this in [`.github/ISSUE_TEMPLATE/bug_report.md`](https://github.com/jackfrued/Python-100-Days/blob/main/.github/ISSUE_TEMPLATE/bug_report.md):

```markdown
---
name: Bug Report
about: Report a defect in the project
title: "[BUG] <short description>"
labels: bug
assignees: ''

---

**Describe the bug**
A clear and concise description of what the bug is.

**Steps to reproduce**
1. 
2. 
3. 

**Expected behavior**
What you expected to happen.

**Environment**
- Python version: `3.12`
- OS: `Ubuntu 24.04`

```

## Summary

- Python-100-Days dedicates **Days 91–100** to team project development, providing an end-to-end blueprint in `Day91-100/91.团队项目开发的问题和解决方案.md`
- The guide advocates for **agile Scrum** over waterfall models, defining clear roles and ceremonies for teams of 8–10 people
- **Git workflows** are central to the methodology, emphasizing protected branches, feature branches, and mandatory Pull Request reviews
- **Automated quality gates** using `flake8`, `pylint`, and CI pipelines (Jenkins/GitHub Actions) prevent defective code from reaching production
- **Issue-driven development** creates traceability from requirements to deployment, utilizing platforms like GitLab, JIRA, or Gitee

## Frequently Asked Questions

### What software process model does Python-100-Days recommend for team project development?

The repository explicitly recommends **agile Scrum** over the traditional waterfall model. According to lines 996–1011 in `Day91-100/91.团队项目开发的问题和解决方案.md`, the guide details Scrum roles including Product Owner, Scrum Master, and Development Team, along with ceremonies like Sprint planning and Daily stand-ups. This approach is favored because it accommodates changing requirements better than rigid sequential models.

### How does the guide suggest structuring Git workflows for team collaboration?

Python-100-Days mandates a **protected main branch** workflow where direct pushes are forbidden (lines 1064–1125). Developers must use feature branches (e.g., `feature/42-add-login`) and submit changes via Pull Requests that require peer review and passing CI checks. The guide compares GitHub-flow and Git-flow branching strategies, recommending branch protection rules to ensure the main branch always remains deployable.

### What tools does Python-100-Days recommend for maintaining code quality in team projects?

The documentation specifies **static analysis tools** `flake8` and `pylint` for automated style and error checking (lines 1037–1040). For continuous integration, it mentions **Jenkins** and **Travis CI** (lines 1195–1220). These tools are integrated into CI pipelines that run on every Pull Request, enforcing code quality standards before any merge can occur.

### How does the repository suggest handling issue tracking in a team environment?

The guide promotes **issue-driven development** where every user story or defect is tracked in dedicated platforms such as **GitLab**, **JIRA**, **Gitee**, or **ZenTao** (lines 1159–1189). Issues should contain structured fields including reproduction steps, environment details, and expected behavior. Branch names should reference issue IDs (e.g., `feature/123-add-auth`) to maintain traceability throughout the development lifecycle.