# Jira Integration

Pull a ticket into context and work on it directly no copy-pasting requirements between tabs, no switching context. C0 reads the ticket, understands what's needed, and helps you implement it.

***

### Connecting Jira

Open C0 navigate to **Jira Integration**, and click **Connect**.

You'll be prompted to authorize C0 with your Atlassian account. Once authorized, select the Jira projects you want c0 to have access to.

***

### Working from a ticket

#### Pull a ticket into context

In any C0 workflow, reference a ticket by its ID:

```
@PROJ-1042 Implement the changes described in this ticket.
```

C0 reads the full ticket title, description, acceptance criteria, comments, attached designs or specs and uses that as the brief for the work.

#### Let c0 interpret the requirements

C0 translates the ticket into a concrete implementation plan:

```
@PROJ-1042 What code changes are needed to implement this?
Walk me through your plan before making any changes.
```

C0 reads the ticket and the relevant codebase, then outlines: which files need to change, what the implementation approach should be, any risks or ambiguities in the requirements, and what tests should be written. You review the plan before C0 does anything.

#### Implement directly

Once you're aligned on the approach, tell C0 to proceed:

```
@PROJ-1042 Implement this. Start with the service layer 
and I'll review before you touch the API routes.
```

C0 makes the changes, explains what it did, and waits for your review at any checkpoints you've specified.

***

### Ticket-aware workflows

#### Debug with ticket context

When debugging a bug ticket, include the ticket for context:

```
@BUG-829 Debug this. The ticket has the reproduction steps and the error logs.
```

C0 reads the reproduction steps and logs from the ticket rather than requiring you to re-type them.

#### Review against acceptance criteria

When reviewing code for a ticket, C0 can check the implementation against the ticket's acceptance criteria:

```
@PROJ-1042 Review my changes against the acceptance criteria in this ticket.
```

C0 reads the criteria from the ticket and flags any gaps in the implementation.

#### Generate tests from a ticket

```
@PROJ-1042 Generate tests that cover the acceptance criteria in this ticket.
```

C0 reads the acceptance criteria and writes tests that verify each one not just generic tests for the code.

***

### Creating and updating tickets from C0

#### Log findings during debugging

If you discover something during a debug or review session that warrants a new ticket a related bug, a missing feature, a tech debt item you can create a Jira ticket without leaving C0:

```
Create a ticket for the N+1 query issue we found in OrderService. 
Label it as a bug, high priority.
```

C0 creates the ticket with a structured description of the issue, including the file name, line number, and explanation it already has from the debug session.

***

### Searching tickets

```
Show me the open tickets assigned to me in the PROJ project.
```

```
Find the ticket for the payment retry logic I think it was filed last month.
```

C0 searches your connected Jira projects and returns matching tickets. You can then pull any of them into context by referencing their ID.

***

### Tips

**Start every feature with the ticket.** Before writing any code, pull in the ticket and ask C0 to walk through what's needed. This is faster than reading the ticket yourself and much better than half-remembering the requirements while implementing.

**Use tickets for bug context.** Bug tickets usually contain the best information about a bug reproduction steps, logs, screenshots, comments from QA. Pull the ticket into debug mode and C0 can read all of that automatically.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.codemate.ai/c0/jira-integration.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.