Personal Repos Get Team-Grade Issue Tracking: GitHub Brings Issue Types and Fields to Personal Accounts
On 11 November 2026, GitHub made issue types and issue fields generally available on personal-account repositories. Types answer 'what kind of work is this' (Bug, Task, Feature by default, up to 25 per account); fields answer 'where does it stand' (Priority, Effort, Start date, Target date by default, up to 25). Both feed Project views, search, bulk edits, the API, and webhooks — plus labels and milestones can now be created directly from an issue.

On 11 November 2026, GitHub posted a short Changelog entry that matters a lot to independent developers: issue types and issue fields are now generally available on repositories owned by personal accounts. Until now, this was a planning capability reserved for organizations — a solo maintainer had to get by with titles, body text, and labels. From today, a personal repository can give every issue a proper type, fill in a few structured fields, and throw the whole lot into a Project view to filter, group, and bulk-edit. The announcement mentions no paywall and no per-plan differences — it is simply available to everyone.
The short version: this is not for big teams, it is for one person
Many people hear "issue types and fields" and assume it is a management tool for big companies, nothing to do with them. That judgement is exactly backwards: big teams already have project managers, processes, and someone to maintain the board — they are not the ones missing this. The people who are missing it are independent developers juggling two or three small projects at once, trying to remember from memory which bug is most urgent and which feature has to ship next week. Until now, a repository only had three kinds of structured information: the title, the body, and labels. Priority had to live inside a label name (like high-priority) or in the first line of the body; a due date lived in a sentence in the body, or in your head. Labels can classify, but they are not structured data: you cannot filter for "priority is high AND target date is this week", and you cannot bulk-change a batch of issues from "medium" to "high" priority.
This update fills exactly that gap: the type answers "what kind of work is this", and the fields answer "where does it stand". Types classify, fields measure, and together they turn an issue from a "note" into a "record". For people who practice vibe coding, the significance is direct: you work alone, but the agents working for you open more PRs and file more issues every day. Without structured information, your repository quickly becomes a pile of similarly titled items you cannot rank by urgency. With types and fields, you can at least do one thing: open a Project view and see at a glance which five items have to be handled this week.
That said, let us be clear: this is not a revolutionary feature, and GitHub is not selling it as one. It is simply a capability organizations have had for a long time, handed down unchanged to personal accounts. The good news is that it works today — no waiting, no application, no plan change. The bad news is that it will not decide anything for you. Types and fields give you the frame; what goes inside it, and how much, depends entirely on your own discipline.
One more thing worth saying: who gets the most out of this, and who can leave it alone for now. If you have one repository with fewer than ten issues, and you remember the state of every item from start to finish, this is surplus to requirements — labels are completely enough, and you should not adopt it just for the sake of it. The people who genuinely benefit are two kinds: first, anyone maintaining several projects at once, with issue counts in double digits, past the point where memory alone keeps track; second, anyone maintaining an open-source project who receives outside contributors — your issue list is a stranger's first impression of you, and a clear structure makes people more willing to pitch in. There is a third group that is easy to overlook: heavy Project board users. Once types and fields are columns in a view, grouping, sorting, and charts all come alive, and half the work you used to do by dragging cards around can now be done with a filter. Conversely, if you never use Projects and only scroll through the issue list, this update will feel minor — set up a view first, and come back to judge it afterwards.
What exactly shipped: five things, one by one
First, issue types. Every issue can carry one type, and there are three by default: Bug, Task, and Feature. You manage them in your personal account settings: under "Code, planning, and automation", open Planning, then Issue types, where you can create new types and edit their names, descriptions, and colors. Each account can have up to 25 types, and the limit is per account — the same set of types is shared across all repositories you own. A type is not just decoration: it shows up in issue lists and on the issue itself, you can filter by it (for example, only type:Bug), and you can use it for grouping and views in Projects. The GitHub docs also record a practical detail: a type can be disabled or deleted. Disabling only hides it temporarily — issues already carrying that type keep it, and re-enabling brings it back. Deleting is permanent, so think before you do it.
Second, issue fields. This is the weightiest part of the update. Four fields come built in: Priority, Effort, Start date, and Target date. You can customize them in the same account settings, up to 25 fields. Fields come in five kinds: text, number, date, single-select, and multi-select — so you can add an "Impact" single-select field, a "Reproduction link" text field, or an "Estimated hours" number field. More importantly, you can pin a field to a specific type: only Feature issues show "Target date", while Bug issues automatically show "Severity"; or you can leave a field unpinned so every issue can fill it in. Fields live in the issue sidebar, alongside assignees, labels, and type. Changes save automatically, and every change is recorded in the issue timeline, noting who changed what and when.
Third, Project views and bulk updates. Types and fields are not confined to a single issue — they can become columns in a Project, where you can group, sort, filter, build charts, and bulk-edit a whole batch of issues. Search understands field syntax too: field.priority:high finds every high-priority issue, and field."target date":>=2026-03-01 finds issues with a target date on or after that day. Previously, answering "which high-priority features are unfinished this week" meant scanning with your eyes, one item at a time; now one query does it.
Fourth, the API and webhooks. REST and GraphQL both have full support: create fields, update fields, set values on an issue, clear values — there are endpoints for all of it. Whenever a field value changes, the issues event fires field_added and field_removed webhooks, carrying the field name, type, new value, and previous value. In other words, you can write a GitHub Action that pins an issue to the top of a Project view the moment its priority becomes "high", or posts a reminder comment when a target date passes. None of that automation comes out of the box — you write the script yourself — but the interfaces are all there.
Fifth, a small convenience fix: you can now create labels and milestones directly from an issue, without jumping to the repository's labels or milestones page. If your label search finds no match, the interface offers to create one on the spot; milestones work the same way — search for "Preview", find nothing, and create a milestone called "Preview" right there. The official image in the Changelog entry shows exactly this scene: a "Set milestone" dialog on a dark green grid background, with "Preview" typed in the search box and "Create new milestone: 'Preview'" underneath. It is a tiny change, but it removes real friction — creating a label used to mean jumping pages, finding the entry point, and jumping back, turning a one-second job into three steps.
Why now: organizations had a year-plus head start
This capability did not appear out of nowhere. Organization accounts got issue types back in April 2025, and issue fields followed in the organization edition in July this year — that timeline comes from community roundups of GitHub's Projects & Issues updates, not from this announcement itself, which does not repeat the history. In other words, organizations have been using it for over a year, fields have been running there for a few months, and GitHub waited until it felt stable before extending it to personal accounts. That also explains why the announcement reads so flat: no launch event, no long blog post, just a Changelog entry — because for GitHub, this is not a new feature launch, it is a wider rollout.
The order itself is worth thinking about. GitHub gave it to organizations first and individuals second, which shows it originally treated this as "team collaboration infrastructure". Extending it to personal accounts now amounts to admitting a reality: today's individual developer does no less work than a small team. One person building with Claude Code, Codex, or Cursor can rack up in a day the number of issues that, a few years ago, took a three-person group. The management burden grew first on the individual side; the tooling arrived late, but it has arrived.
One more piece of context: on the same day, GitHub also posted Changelog entries including enterprise GitHub Apps managing Copilot seats. November has been a dense week for the Changelog — models, reviews, dashboards, all moving. But for independent developers, the issue types and fields entry is probably the most useful of the lot, because it does not depend on which model you use or which plan you pay for. Open settings and it works.
The three most useful patterns for vibe coders
The first pattern is triage for agent output. Many people's workflow now looks like this: an agent fixes bugs and adds features, then opens PRs and files issues as it goes. The problem is that agent-filed issues all have similar titles — you cannot tell how urgent they are without opening each one. You can set one rule: every agent-filed issue starts as type Task, and you (or your review process) fill in the Priority field after reading it, with Effort as your estimated cost of checking it. That gives your issue list a first layer of order: which items are fresh submissions awaiting review, and which you have read and confirmed as real work. The type acts as the boundary line of a human review step.
The second pattern is treating fields as a lightweight database. The most common flaw of solo projects is "did a lot, remember none of it". The four default fields already support a minimal system: Priority decides who goes first this week, Effort estimates how long each item takes, and Start date and Target date box in the timeframe. Add one custom field and you are done — for example, a "Status" single-select (to do / in progress / awaiting verification / done), or a "Module" single-select (frontend / backend / deployment). The benefit of fields is forced structure: you can no longer fob yourself off with "probably next week" — once a Target date is filled in, overdue issues surface by themselves. Sort a Project view by Target date, check it once a week, and you know what has slipped.
The third pattern is making an open-source project legible to visitors. If you maintain a small open-source project, the issue list is a new contributor's first impression. Types and fields make that first impression much clearer: a newcomer can see at a glance which Tasks are good first issues, which Bugs are high priority, and which Features already have target dates. Field visibility is controllable too: you can make some fields public so everyone can see them, or restricted so only the repository owner and collaborators see them, keeping internal assessments internal. The GitHub docs state explicitly that repositories owned by personal accounts support both visibility settings, set once and effective across the repository.
Do not configure everything at once: four boundaries to think through first
First, fields only work on issues — pull requests are not supported. The GitHub docs say so plainly: issue fields are currently available on issues only, and pull requests do not support issue fields. That means you cannot stick a "Priority" field on a PR, nor filter the PR list by field. If your development runs on PRs, this tooling cannot help on that side; it manages issues only. Do not expect it to, and do not bend it to fit.
Second, field values cannot be pre-filled from a URL parameter or set through issue templates. The docs state this too: issue fields cannot currently be pre-filled via URL query parameters or set through issue templates — you set them in the issue sidebar, in Projects, via the API, or with GitHub Actions. In other words, you cannot send someone a link that opens with field values already filled in, and a new issue's fields always need someone to fill them in the first time. For a personal project this is a minor issue — the person filling them in is you. But if you were hoping contributors would file issues with fields pre-filled, that does not work yet.
Third, do not start by creating all 25. Twenty-five types and 25 fields are a ceiling, not a target. Every type and field you add costs maintenance: one more choice every time you open an issue, one more thing to think about every time you change the rules. For a one-person project, the three default types plus the four default fields, with one or two custom fields added, are usually enough. Run with that for a month, see which fields you actually filter by every week and which ones you never touched after creating them, then decide what to add or remove. Remember, deleting a type is permanent — confirm no issue still carries it first. Disabling is much safer: it puts the type away, and you can bring it back later.
Fourth, structure is not discipline. Types and fields can write down "what matters", but writing it down is not the same as doing it. The tooling gives you the frame; the discipline is still yours: check a Project view once a week, push back an overdue Target date or lower a priority, and that ten minutes is worth more than ten new fields. In the other direction, if you build a pile of fields and never look at them, they only add ten seconds to every new issue until you start avoiding issues altogether and talking to the agent in the chat box instead. A tool's value depends on whether you are willing to spend ten minutes a week maintaining it.
Three steps to get started, ten minutes total
Step one: set up the frame in account settings. Click your avatar, open Settings, find Planning under "Code, planning, and automation", and open the Issue types and Issue fields pages. Do not rush to add types: run with the default Bug, Task, and Feature for a while, and only add more when you genuinely need them — a Docs type for documentation work, say, or a Review type for agent submissions awaiting review. Same for fields: start with the four defaults and add only the one you need most. For most people, that one is "Status".
Step two: practice on the three to five issues you are already working on. Open one, pick a type and fill in the fields in the sidebar, check whether fields pinned to that type appear automatically, then try field.priority:high in the search box and see whether the results look right. It takes a few minutes, but it answers one question: does your classification actually match how you work? If filling things in feels awkward, the design of your types or fields is wrong — fix it now, while the issue count is still small.
Step three: build the Project view. Create a Project, add types and fields as columns, sort by Target date, and save a "high priority this week" filtered view. From now on, check that view once a week instead of scrolling the issue list. Once that routine is running smoothly, consider API or Actions automation — a reminder when a field changes, for example. Automation always comes last: a process people actually use first, then a process that runs itself.
Closing: a small update with a big signal
On its own, this update is genuinely small: no new model, no new interface, no flashy demo. GitHub simply copied a capability that already existed from organization accounts to personal accounts. But the signal behind it is worth reading carefully: GitHub is finally acknowledging, in the product itself, that an individual developer is not a "shrunken team" but a complete working unit in their own right. One person needs types, fields, views, and bulk operations too, because one person's workload stopped being something a "notepad plus a few labels" could handle a long time ago.
For VibeFix readers, that signal has a practical edge: the faster AI lets you write code, the faster your management burden grows. An agent can hand you ten issues overnight; if your ability to sort them does not keep up, your repository quickly becomes a pile of items you cannot rank. What GitHub is offering here is not an answer, but a cheap tool: ten minutes to set up the frame, ten minutes a week to maintain it, and your issue list becomes readable again. The tool will not decide for you, but it gives your decisions somewhere to land. Start with the three default types and the four default fields, run with them for a month, and only then decide whether to add more — that is the right way to treat a "small update" like this.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.