## Inspiration
Software engineers do not receive work from one clean place. A single day can include Jira tickets, ServiceNow defects, GitHub PRs, Outlook emails, Slack mentions, meeting notes, and manager follow-ups. Important tasks often get duplicated across systems or hidden inside long messages.
TaskPilot AI was inspired by this daily context-switching problem. We wanted to build an AI assistant that acts like a trusted execution buddy: it finds the real work, removes noise, explains priorities, and helps engineers focus on the next best task.
## What It Does
TaskPilot AI is a cross-platform desktop assistant for engineers and engineering managers.
It aggregates tasks from Jira, GitHub, ServiceNow, Outlook, Slack, and meeting notes. It uses NLP-style extraction to find hidden action items in unstructured text, deduplicates related work across systems, and ranks tasks using severity, deadline, business impact, blockers, duplicate confidence, owner pressure, and source type.
Engineers get a focused execution dashboard with a ranked queue, daily plan, priority explanation, and next-task assignment.
Managers get a separate dashboard for team workload, blockers, SLA risks, priority lanes, and delivery decisions.
The app also includes a floating desktop companion that stays available on screen for quick scans, task explanations, and approval-gated actions.
## How We Built It
We built TaskPilot AI as an Electron desktop application so it can run on both macOS and Windows.
The frontend uses vanilla JavaScript, HTML, and CSS. The backend uses Node.js and local JSON datasets that simulate Jira sprint boards, ServiceNow defects, GitHub work, Outlook emails, Slack mentions, meeting notes, calendar blocks, and user profiles.
The task engine performs the main workflow:
1. Ingest raw task signals from all datasets.
2. Normalize text from structured and unstructured sources.
3. Detect duplicates using shared IDs, token similarity, and phrase overlap.
4. Merge duplicates into canonical tasks.
5. Score tasks using priority features.
6. Generate ranked queues, alerts, daily plans, and execution briefs.
The prioritization model uses signals such as:
- Severity
- Due date
- Business impact
- Blockers
- Duplicate confidence
- Source type
- Owner workload
- NLP-extracted hidden actions
We also added Supabase Google authentication support for engineer and manager profiles, Gemini API support through backend environment variables, and a TEE-style trust envelope for sensitive OCR/screen workflows.
## How Codex and GPT-5.6 Helped
Codex and GPT-5.6 were central to the workflow.
GPT-5.6 helped us reason through the product idea, user personas, prioritization logic, and demo story. Codex helped turn those decisions into working code across the Electron app, frontend dashboards, backend datasets, task engine, Supabase setup, and README documentation.
Codex accelerated the project by helping us:
- Convert the hackathon idea into a technical architecture.
- Build the Electron desktop shell.
- Implement the floating companion agent.
- Create separate engineer and manager dashboards.
- Improve UI/UX through iterative screenshot feedback.
- Add dataset ingestion, deduplication, ranking, and next-task assignment.
- Add setup documentation and judging-focused README sections.
- Run tests and build checks while iterating quickly.
The key product decisions were still made by us: the target users, role-specific dashboards, approval-gated execution model, sample datasets, and final demo flow.
## Challenges We Faced
One challenge was making the project feel like a real application rather than just a chatbot or dashboard. We solved this by building a desktop app with a floating companion and role-specific workflows.
Another challenge was making the manager and engineer views meaningfully different. Engineers need a focused execution queue, while managers need risk, workload, and team-level visibility. We redesigned the UI around those different jobs.
Deduplication was also challenging because the same task can appear in different forms across Jira, email, incidents, and Slack. We handled this using a combination of shared IDs, normalized tokens, phrase matching, and duplicate confidence.
A final challenge was balancing AI autonomy with user control. We designed TaskPilot so the agent can suggest, explain, and prepare actions, but final execution remains approval-gated.
## What We Learned
We learned that task prioritization is not just about sorting by deadline. Real engineering priority depends on context: business impact, blockers, duplicate signals, source reliability, manager escalations, and hidden commitments from unstructured text.
We also learned that role-specific UX matters. The same data needs to be presented differently for engineers and managers.
Most importantly, we learned how powerful Codex can be when used as an engineering collaborator. It helped us move faster, explore alternatives, and keep implementation aligned with the product idea.
Log in or sign up for Devpost to join the conversation.