-
Sandbox_results
-
GAIDW method I used
-
Okozati_predictive_AI
Inspiration.
Karalin.ai is being developed as a professional SaaS platform for algorithmic trading. The long-term goal is to build a profitable technology business around predictive AI rather than a business that depends on consulting or custom development.
For OpenAI Build Week, I focused on one specific component of that larger system: developing a governed engineering workflow for building a production-quality predictive AI ensemble using GPT-5.6 and Codex.
What it does.
The Build Week project develops the predictive AI ensemble responsible for evaluating market conditions and selecting trading decisions.
Rather than relying on a single machine learning model, the system constructs a complete supervised-learning pipeline that transforms synchronized market data into stationary features, groups similar market conditions, trains multiple model families, evaluates their performance, and prepares validated models for deterministic scenario testing before production deployment.
Equally important, the project demonstrates a repeatable engineering process for using GPT-5.6, Codex, GitHub and formal software specifications to build complex AI systems while maintaining architectural consistency.
How we built it
Development was driven by software engineering specifications stored in GitHub.
The workflow follows a structured cycle:
Design and refine the architecture in ChatGPT. Convert the design into detailed implementation specifications. Commit the specifications to GitHub. Use Codex with GPT-5.6 to implement the required functionality. Perform an adversarial review using GPT-5.6 Sol. Repair identified issues. Execute regression tests. Produce evidence packages documenting the completed implementation. Commit only validated changes. ChatGPT accesses github to review and discuss with me, the human engineer.
This process was repeated throughout Build Week while implementing the predictive AI ensemble.
Challenges we ran into
Building a large multi-stage AI system revealed that conversational design and autonomous code generation can diverge if they are not governed by a shared specification.
Early iterations occasionally implemented technically reasonable solutions that differed from the intended architecture. This highlighted the importance of treating the specification—not the conversation—as the authoritative source of truth.
Another challenge was maintaining consistency across multiple implementation sessions while protecting previously completed functionality from regression.
Accomplishments that I've proud of
During Build Week we completed major portions of the predictive AI pipeline, including:
synchronized market data preparation stationary feature generation independent clustering for multiple trading routes supervised ensemble training using XGBoost, CatBoost and LightGBM deterministic scenario validation a governed implementation workflow using GPT-5.6 Sol and Codex
Perhaps the most significant accomplishment was developing a repeatable engineering workflow that substantially improved consistency between software specifications and generated implementations.
What I learned
The most valuable lesson was that AI-assisted software engineering requires governance as much as code generation.
I found that implementation quality improved significantly when every development cycle followed the sequence:
Read Specification → Implement → Adversarial Review → Repair → Regression Test → Evidence Package → Git Commit
GPT-5.6 Sol was particularly effective during the review and validation stages because it was better able to reason about architectural consistency across a large codebase.
Although this workflow is still evolving, it has already reduced implementation drift and increased confidence in production-quality changes.
What's next for Okozeti boost AI productivity flow
The next phase is to continue refining the governed development workflow. The system needs further work around managing trades in real time and coordinating exit of multiply clients.
Areas of active research include:
improving synchronization between conversational planning and implementation automatically verifying that Codex has fully interpreted a specification before implementation begins detecting specification omissions before code generation strengthening automated adversarial review expanding the methodology into a reusable engineering framework that other developers can apply to complex AI systems
Ultimately, the goal is not only to build a predictive AI platform, but also to establish a practical methodology for using GPT-5.6 and Codex to engineer large, production-quality software systems.
Log in or sign up for Devpost to join the conversation.