Zum Inhalt

Lineare Cheat Blatt

generieren

Überblick

Linear ist ein modernes Ausgabe-Tracking- und Projektmanagement-Tool für leistungsstarke Teams. Es konzentriert sich auf Geschwindigkeit, Einfachheit und leistungsfähige Workflows, um Ingenieurteams dabei zu unterstützen, bessere Produkte schneller mit optimierter Problemverfolgung, Projektplanung und Teamkooperation aufzubauen.

ZEIT Anmerkung: Freier Platz für kleine Teams. Bezahlte Pläne starten bei $8 / Benutzer / Monat für erweiterte Funktionen.

Erste Schritte

Kontoaufbau

```bash

Sign up options:

1. Visit linear.app

2. Sign up with email or GitHub/Google account

3. Create workspace or join existing team

4. Set up your first project

Workspace creation:

- Choose workspace name and URL

- Invite team members

- Configure integrations

- Set up project structure

```_

Team Setup

```bash

Team configuration:

1. Create teams for different areas (Frontend, Backend, Design)

2. Set team leads and members

3. Configure team-specific workflows

4. Set up team labels and priorities

5. Define team cycles and milestones

```_

Projektstruktur

```bash

Project organization:

- Teams: Organizational units (Engineering, Design, Product)

- Projects: Feature sets or initiatives

- Issues: Individual tasks, bugs, or features

- Cycles: Time-boxed sprints (1-4 weeks)

- Milestones: Major project goals

```_

Emissionsmanagement

Probleme schaffen

```bash

Quick issue creation:

Keyboard shortcut: C (from anywhere in Linear)

Or click "New Issue" button

Issue fields:

- Title: Clear, descriptive summary

- Description: Detailed requirements/context

- Assignee: Team member responsible

- Priority: Urgent, High, Medium, Low

- Status: Backlog, Todo, In Progress, Done

- Labels: Custom tags for categorization

- Project: Associated project/initiative

- Estimate: Story points or time estimate

```_

Vorlagen ausstellen

```markdown

Bug Report Template

Bug Description: Brief description of the issue

Steps to Reproduce: 1. Step one 2. Step two 3. Step three

Expected Behavior: What should happen

Actual Behavior: What actually happens

Environment: - Browser/OS version - Application version - Additional context

Screenshots/Videos: Attach relevant media ```_

```markdown

Feature Request Template

Feature Summary: Brief description of the feature

Problem Statement: What problem does this solve?

Proposed Solution: How should this work?

Acceptance Criteria: - [ ] Criterion 1 - [ ] Criterion 2 - [ ] Criterion 3

Additional Context: Design mockups, user stories, etc. ```_

Lieferung Workflow

```bash

Standard workflow states:

1. Backlog - Not yet planned

2. Todo - Planned for current cycle

3. In Progress - Actively being worked on

4. In Review - Code review/testing

5. Done - Completed and deployed

Custom workflow states:

- Blocked - Waiting on external dependency

- Needs Design - Requires design input

- Ready for QA - Ready for testing

- Deployed - Live in production

```_

Keyboard Shortcuts

```bash

Global shortcuts:

G + I # Go to Issues G + P # Go to Projects G + T # Go to Teams G + R # Go to Roadmap G + S # Go to Settings / # Global search ? # Show all shortcuts

Issue shortcuts:

C # Create new issue E # Edit current issue D # Duplicate issue A # Assign to me U # Mark as urgent Enter # Open issue details Esc # Close modal/go back ```_

Emissionsaktionen

```bash

Status changes:

1 # Set to Backlog 2 # Set to Todo 3 # Set to In Progress 4 # Set to In Review 5 # Set to Done

Priority changes:

Shift + 1 # Set to Urgent Shift + 2 # Set to High Shift + 3 # Set to Medium Shift + 4 # Set to Low

Bulk actions:

Cmd/Ctrl + A # Select all Shift + Click # Select range Cmd/Ctrl + Click # Multi-select ```_

Suche und Filter

```bash

Search operators:

assignee:me # Issues assigned to me status:todo # Issues in Todo status priority:high # High priority issues label:"bug" # Issues with bug label project:"Mobile App" # Issues in specific project created:>2024-01-01 # Issues created after date updated:<7d # Issues updated in last 7 days team:engineering # Issues for engineering team

Combined search:

assignee:me status:todo priority:high ```_

Projektleitung

Fahrräder (Sprints)

```bash

Cycle management:

1. Create new cycle (typically 1-2 weeks)

2. Set cycle goals and scope

3. Add issues to cycle

4. Track progress during cycle

5. Review and close cycle

Cycle planning:

- Estimate issue complexity

- Balance team capacity

- Set realistic goals

- Plan for dependencies

- Include buffer time

```_

Planung von Fahrplänen

```bash

Roadmap features:

- Timeline view of projects

- Milestone tracking

- Dependency management

- Progress visualization

- Team capacity planning

Roadmap best practices:

- Link issues to projects

- Set realistic timelines

- Regular progress updates

- Stakeholder communication

- Scope adjustment as needed

```_

Projektverfolgung

```bash

Project metrics:

- Completion percentage

- Issue velocity

- Cycle burndown

- Team performance

- Time to resolution

Progress indicators:

- Status distribution

- Priority breakdown

- Assignee workload

- Label analysis

- Trend visualization

```_

Team Collaboration

Kommentare und Mentions

```bash

Comment features:

- @mention team members

- Reference other issues (#123)

- Add emoji reactions

- Thread conversations

- File attachments

Mention syntax:

@username # Mention specific user @team-name # Mention entire team

123 # Reference issue number

```_

Mitteilungen

```bash

Notification types:

- Issue assignments

- Status changes

- Comments and mentions

- Project updates

- Cycle changes

Notification settings:

- Email preferences

- Slack integration

- Desktop notifications

- Mobile push notifications

- Digest frequency

```_

Aktivitäten Tracking

```bash

Activity feeds:

- Personal activity

- Team activity

- Project activity

- Issue history

- System changes

Activity filters:

- By user

- By date range

- By action type

- By project/team

- By issue status

```_

Integration

Gier Integration

```bash

GitHub integration:

1. Connect GitHub repository

2. Link commits to issues

3. Auto-close issues on merge

4. Branch name generation

5. PR status tracking

Commit message format:

git commit -m "Fix user authentication bug

Fixes LIN-123"

Branch naming:

feature/lin-123-user-authentication bugfix/lin-456-login-error ```_

Slack Integration

```bash

Slack features:

- Issue notifications

- Create issues from Slack

- Status updates

- Team mentions

- Project updates

Slack commands:

/linear create [title] # Create new issue /linear assign [issue] [@user] # Assign issue /linear status [issue] [status] # Update status /linear search [query] # Search issues ```_

Integration von Figma

```bash

Figma connection:

1. Install Linear Figma plugin

2. Link design files to issues

3. Create issues from designs

4. Track design implementation

5. Sync design changes

Design workflow:

- Link mockups to features

- Create implementation issues

- Track design review status

- Manage design system updates

```_

API Integration

```bash

GraphQL API:

Endpoint: https://api.linear.app/graphql

Authentication: API key or OAuth

Create issue via API:

curl -X POST https://api.linear.app/graphql \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "query": "mutation IssueCreate($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id title } } }", "variables": { "input": { "title": "New API Issue", "description": "Created via API", "teamId": "TEAM_ID" } } }' ```_

Erweiterte Funktionen

Kundenspezifische Felder

```bash

Custom field types:

- Text fields

- Number fields

- Select dropdowns

- Multi-select

- Date fields

- URL fields

Use cases:

- Customer impact level

- Technical complexity

- Business value

- Component affected

- Release version

```_

Automatisierungsregeln

```bash

Automation triggers:

- Issue created

- Status changed

- Assignee changed

- Label added/removed

- Priority changed

Automation actions:

- Set status

- Assign to user

- Add/remove labels

- Set priority

- Add to project

- Send notification

Example automation:

When issue labeled "bug" is created

→ Set priority to "High"

→ Assign to QA team lead

→ Add to "Bug Fixes" project

```_

Ansichten und Filter

```bash

Custom views:

- My Issues

- Team Backlog

- Current Cycle

- Urgent Issues

- Recently Updated

View configuration:

- Filter criteria

- Sort order

- Group by field

- Display columns

- Save and share

```_

Einblicke und Analytics

```bash

Team metrics:

- Velocity trends

- Cycle completion rates

- Issue resolution time

- Priority distribution

- Workload balance

Project analytics:

- Progress tracking

- Scope changes

- Timeline adherence

- Resource allocation

- Risk indicators

```_

Linear CLI

Installation

```bash

Install Linear CLI

npm install -g @linear/cli

Authenticate

linear auth

Verify installation

linear --version ```_

Grundlegende Befehle

```bash

List issues

linear issue list

Create issue

linear issue create "Fix login bug" --team engineering

Update issue status

linear issue update LIN-123 --status "In Progress"

Assign issue

linear issue assign LIN-123 @username

Search issues

linear issue search "authentication"

List projects

linear project list

List teams

linear team list ```_

Erweiterter CLI Verwendung

```bash

Create issue with details

linear issue create \ --title "Implement user dashboard" \ --description "Create responsive user dashboard with analytics" \ --team frontend \ --priority high \ --project "Q1 Features" \ --labels feature,frontend

Bulk operations

linear issue list --assignee me --status todo | \ xargs -I {} linear issue update {} --priority high

Export data

linear issue list --format json > issues.json

Import from CSV

linear issue import --file issues.csv --team engineering ```_

Workflow Optimierung

Agile Workflows

```bash

Scrum workflow:

1. Sprint planning (cycle creation)

2. Daily standups (status updates)

3. Sprint review (cycle completion)

4. Retrospectives (team feedback)

Kanban workflow:

- Continuous flow

- WIP limits

- Pull-based system

- Cycle time optimization

```_

Schätzung der Emissionen

```bash

Estimation methods:

- Story points (Fibonacci: 1, 2, 3, 5, 8, 13)

- T-shirt sizes (XS, S, M, L, XL)

- Time estimates (hours/days)

- Complexity levels (1-10)

Estimation guidelines:

- Include testing time

- Account for code review

- Consider dependencies

- Add buffer for unknowns

```_

Prioritätsmanagement

```bash

Priority framework:

Urgent: Critical bugs, security issues

High: Important features, customer requests

Medium: Nice-to-have improvements

Low: Technical debt, optimizations

Priority matrix:

High Impact + High Effort = High Priority

High Impact + Low Effort = Quick Wins

Low Impact + High Effort = Avoid

Low Impact + Low Effort = Fill-ins

```_

Teammanagement

Rollenbasierter Zugriff

```bash

User roles:

- Admin: Full workspace access

- Member: Standard team access

- Guest: Limited project access

- Viewer: Read-only access

Permission levels:

- Create/edit issues

- Manage projects

- Configure teams

- Access analytics

- Manage integrations

```_

Team Organisation

```bash

Team structure:

- Engineering teams by specialty

- Cross-functional squads

- Project-based teams

- Geographic distribution

- Skill-based grouping

Team settings:

- Default assignees

- Workflow states

- Issue templates

- Notification preferences

- Integration configurations

```_

Performance Tracking

```bash

Individual metrics:

- Issues completed

- Average resolution time

- Quality indicators

- Collaboration score

- Goal achievement

Team metrics:

- Velocity consistency

- Cycle predictability

- Collaboration patterns

- Knowledge sharing

- Process adherence

```_

Best Practices

Ausgabe Schreiben

```bash

Title best practices:

- Start with action verb

- Be specific and clear

- Include context when needed

- Use consistent naming

- Avoid technical jargon

Description guidelines:

- Provide clear context

- Include acceptance criteria

- Add relevant links/references

- Specify edge cases

- Include mockups/examples

```_

Projektorganisation

```bash

Project structure:

- Clear project goals

- Defined scope boundaries

- Realistic timelines

- Resource allocation

- Success metrics

Milestone planning:

- Meaningful checkpoints

- Deliverable outcomes

- Stakeholder alignment

- Progress indicators

- Risk mitigation

```_

Team Collaboration

```bash

Communication guidelines:

- Regular status updates

- Clear documentation

- Proactive problem reporting

- Knowledge sharing

- Constructive feedback

Meeting efficiency:

- Agenda-driven discussions

- Action item tracking

- Decision documentation

- Follow-up accountability

- Time-boxed sessions

```_

Fehlerbehebung

Gemeinsame Themen

```bash

Performance problems:

- Clear browser cache

- Check internet connection

- Disable browser extensions

- Try incognito mode

- Contact support if persistent

Sync issues:

- Refresh the page

- Check integration status

- Verify permissions

- Re-authenticate connections

- Review webhook configurations

```_

Datenverwaltung

```bash

Data export:

- Issue export (CSV/JSON)

- Project data backup

- Comment history

- Attachment downloads

- Analytics reports

Data import:

- CSV issue import

- Migration from other tools

- Bulk user creation

- Project template import

- Integration data sync

```_

Integration Debugging

```bash

GitHub integration issues:

- Check repository permissions

- Verify webhook configuration

- Test commit message format

- Review branch protection rules

- Validate API access

Slack integration problems:

- Re-authorize Slack app

- Check channel permissions

- Verify bot installation

- Test notification settings

- Review workspace settings

```_

Sicherheit und Compliance

Datensicherheit

```bash

Security features:

- SOC 2 Type II compliance

- GDPR compliance

- Data encryption at rest

- TLS encryption in transit

- Regular security audits

Access control:

- SSO integration

- Two-factor authentication

- IP allowlisting

- Session management

- Audit logging

```_

Datenschutzkontrolle

```bash

Data handling:

- Data residency options

- Retention policies

- Deletion procedures

- Export capabilities

- Privacy settings

User privacy:

- Profile visibility

- Activity tracking

- Notification preferences

- Data sharing controls

- Consent management

```_

Mobile App

iOS / Android Funktionen

```bash

Mobile capabilities:

- Issue creation/editing

- Comment management

- Status updates

- Push notifications

- Offline access

Mobile shortcuts:

- Quick issue creation

- Voice-to-text input

- Photo attachments

- Barcode scanning

- Location tagging

```_

Mobile Workflow

```bash

On-the-go usage:

- Triage notifications

- Quick status updates

- Emergency issue creation

- Team communication

- Progress checking

Mobile optimization:

- Touch-friendly interface

- Gesture navigation

- Offline synchronization

- Battery efficiency

- Data usage control

```_

Ressourcen

Dokumentation

Gemeinschaft

  • [Linear Community](URL_3_
  • (URL_4_)
  • [Twitter aktualisiert](URL_5_

Ausbildung