If you want to do something very close to professional software development, but without writing code manually, this is the workflow I follow. Hope this helps. Install mattpocock skills on your copilot/claude/codex/opencode. Here's how to use it in a step by step manner. Step 1: /grill-me or /grill-with-docs for closing the gap on requirements and create a rock solid product requirements document. Step 2: /to-prd - committing the grilled requirements into a product requirement document in markdown format. Step 3: /to-issues once you verify the requirements are rock solid, you can convert them to issues (jira tickets proxy) Step 4: /tdd - use a red-green approach to write failure cases tests first, then implementation against that, then write success cases, then implementation against that Step 5: /diagnose or /triage - use this to diagnose and fix any issues arising from implementation - you can also start with this for bug tickets by pointing to the relevant services. Step 6: (This is a separate skill that's part of a different skills repo called 'ponytail') use /ponytail: review skill for code review to identify cases where you can simplify the code, avoid redundancy, avoid over-engineering. ex: "Pull the latest changes from the repo's develop branch, checkout a new branch named "live_scanner" (for ex) and create a worktree out of it. All the work for this task will go into that worktree. There's a requirement to create a live scanning ability where the scanners can be configured via yaml as conditions, and the end product would have a neat and beautiful HTML page which auto-refreshes every minute with the scan results. Zerodha API streams live tick data through websockets, we have to get the tick data, convert them to 1-min timeframe data on each minute end, and store them in postgresql database intraday data table. Alongside, each scanner should also run the scan against the latest data - including historical data where scan demands the same. I want you to /grill-me to close the gap on the requirements for this task after going through the existing repository code. Once we have all the requirements and gaps closed, you will convert the grilled requirements /to-prd within a folder inside the .scratch folder with the name "live_scanner" as "PRD.md" I will go through the PRD and approve it or we'll discuss changes if any. Once that is done, you'll convert the PRD /to-issues within the same folder as the PRD. Once I approve of the issues breakdown and the granularity, dependencies, etc., you will start implementing the issues in the order of dependency with a red-green approach using /tdd Generously use /diagnose skill to figure out any and all issues arising in the tdd process and fix them. Once the implementation of all these issues are done, use /ponytail:review skill to review the implementation for simplicity, overengineering, and redundancies. Once you have the review comments, fix them in a separate commit. For each issue, you'll create separate commits. You'll have to stage the relevant files, create the commit with meaningful description of the work done within that issue, and you'll do all this in HITL mode (I'll be verifying each issue's outcome manually and reviewing the code as well). Once all the issues are implemented, you'll finalize the review fixes, create separate commit for the review fixes, and create a pull request against the develop branch from this feature branch."