I've always worked by a golden rule for AI generated software, the 'Blast Zone must be small', what does that mean, well it means:
- nothing absolutely business critical
- nothing that handles money
- nothing that handles sensitive data
- no auth/access control
That way if it goes wrong then at least the damage is small and contained.
This has lead me to only create small less exciting solutions, particularly for Power App Code Apps. But with the recent glut of reverse engineering I've seen (admittedly buggy) vibe coded Photoshop and Office apps, I started to want to push some boundaries.
So my idea was, can I create my own implementation of the software I recent paying for the most..... Jira.
On top of that I wanted to do it as a Code App, that way I get to see just how far we can push the platform, and avoid auth etc.
So I give you Power Jira, aka Pira 😎
Before we start I'm using CodeApp JS, a custom cli that allows me to build in vanilla JavaScript instead of React, but the below process should be the same, it may just look a little different
So this is my workflow
- Create scope and break it into features
- Decide on UI/UX
- Implement features
- Pain points
- Customise
- End Product
1. Create scope and break it into features
If smaller applications I normally just go for a strong prompt, and then increment over it, but with something big my approach is to fall back into an agile mindset. I break it up into features that add capability, with each feature in theory returning value that could be released. The reason for this is 2 fold
- It allows incremental testing and course correcting
- Allows the model to minimalize context and stay on track
To build out the features I normally use https://chatgpt.com, you can use any LLM chat I just personally prefer GPT models for planning (I use the chat instead of GitHub Copilot because its free 😎)
This isn't plan mode, this is more of a conversation, I ask ChatGPT for advice on my idea, and we will improve it over a few messages. At the end I ask it to create me a markdown file to handover to codex (even though its GitHub Copilot).
I ended up with these features
- Phase 1 — Foundation - Projects, issues, Kanban, comments and history
- Phase 2 — Agile delivery - Backlog, sprints, epics and reporting
- Phase 3 — Productivity - Workflow configuration, attachments and notifications
- Phase 4 — Advanced features - Automation, time tracking and analytics
And below are the supporting docs
- README.md - Project overview and instructions for Codex
- Server-side Dataverse - Plug-ins, Custom APIs, concurrency and validation
- Security roles - Admin, Project Lead, Contributor and Read-only roles
- Dataverse schema and ERD - Table definitions, relationships, alternate keys and Mermaid diagram
If you want to see the actual md files they are here https://github.com/wyattdave/Pira/tree/main/docs
At this point I reviewed the readme, the roles (super important) and the Dataverse schema. I didn't need to make any changes (mainly because Jira has a very open RBAC with the plug-ins enforcing rules rather then direct permissions).
In theory we could stop at any phase and still have a product that adds value.
2. Decide on UI/UX
Although I have everything planned I still have one missing piece, and it can be very important, what UI is the app going to use.
I fall back to my favourite approach, simple html mock-ups with Anthropic's frontend-design skill. I was a little limited this time as I wanted it to still feel like Jira, so they are not as varied as they normally are.
After a few "I like x from mock-up 2 can you add it to mock-up 1" prompts I ended up with what I wanted and then I could then start the main build.
The prompt was:
"Im creating my own version of Jira, the idea is to simplify it but cover the key features that I need. I have prepared implementation phases, database designs, roles and plug-ins, and built on a mock-up of my desired UI. Can you complete phase 1 with the following nfr's
- dont use standard plug-ins, use low-code power fx plug-ins, write the code and I can upload them
- don't worry about the security roles, I will implement them, just provide me with exactly what you want
- if in doubt ask me, and make sure you use required skills."
As you can see it asked me to build the tables, but I had a cli command it could use so I asked it to use that and it went and built them for me. And it also included a list of all of the things I need to do.
I then completed some basic testing, identifying a few things that were either their own prompt or I could roll into the phase 2.
And that's the process, create feature, test, refine/debug, next feature.
4. Pain points
The thing you need to understand about me is I'm a little lazy, and after manually entering 7 Dataverse Low-Code Plug-ins I was getting bored and frustrated. The UI is very buggy and I think Microsoft has forgotten about them, so I decided that maybe I could make my own.
The first thing I did was repeat my process, I want back to https://chatgpt.com and asked it is it possible to create my own UI for plug-ins. It said yes, and recommended being out a simple UI so that we could test it. Though it called out that we would need to register an SPN and it couldn't deploy them. Luckily I knew a way to use the CLI's auth and that we could simply add it to a solution and us the unbound deploy api to upload it.
After I had it working I then went to the next step, turning it into a CLI, because then my agent can do it for me 😎
This turned out to be a good investment, as by time I completed phase 4 I had 31 plug-ins setup!
If you are lazy like me and want to use it, its free and open source, install from npm here: https://www.npmjs.com/package/dataverse-plugins-native
I think this is something key we should remember, sometimes its quicker to create borderline disposable software to help us build
5. Customise
Now here's the best bit of being our own version of Jira, we can make it just the way we want. Jira integrates with GitHub, but in my case Im a Power Platform development team, so I want to integrate directly with the Power Platform.
So I added the ability to lookup and select a solution in dev, test, stage, and prod. I also added in a version number per story/epic, so that we can close the link and see what stage the epic is in.
6. End Product
And that's it, in space of a few hours we have Pira, Jira hosted on Dataverse and Power Platform.
It has the below database tables all setup:
Full res ERD here
It has the following key features:
- Projects
- Kanban and Sprint Boards
- Backlog, sprints
- Epics, Story's, Bugs, Tasks
- Releases
- Dependencies
- Reports
- Comments
- Log Work
- Attachments
- Linked Solutions
just to name a few, and just like the Power Platform integration, you can add any features you require.
Moving Story's and checking reports
Create Story
Kanban Board
Reports
Wrap up
I'm not going to lie, I was super impressed by just how good Opus 5.5 was, I had a handful of small bugs and a couple of tweaks that I want changed, it got 99% right without my input. On top of that it shows just how robust Dataverse is, along with surprisingly Low-Code plug-ins (obviously the runtime is rock solid even though the developer portal isn't).
The big question is would I feel confident to use this in prod, and the answer is maybe. If I was in a smaller org then I would definitely consider it, likewise if I had more resources to fully review the code and build out a robust back out plan, then yes. But in most cases not quite yet, though that isn't a capability concern, just more of a risk avoidance mantra.
I've open sourced Pira if you want a play or to build on top of it, the repo has all of the md files, tests, low-code plug-ins, code, and the solution zip (if you just want to import it). It uses https://codeappjs.com/ if you want to use built in agent.md, skills, and cli, though I suspect your agent of choice will be able to pick it up just by the code base.
Top comments (0)