<![CDATA[Romavm]]>https://romavm.devRSS for NodeSat, 11 Apr 2026 04:48:00 GMT60<![CDATA[Tried Kiro for 5 days - feels like a below mid-level dev]]>https://romavm.dev/tried-kiro-for-5-dayshttps://romavm.dev/tried-kiro-for-5-daysSun, 24 Aug 2025 07:10:50 GMTI used Kiro for 5 days to complete my hackathon project (analyzing GitHub repositories).

My quick eval: Kiro feels like a below mid-level dev.

  • Coding skills: mid-level

  • Engineering skills: below mid

  • Discipline: below mid

Here’s how Kiro stacks up vs. a senior dev (based on my 25 years in software):

What Kiro doesWhat a senior doesIdeas to fix Kiro
Chooses a random repo with 100+ forksChooses a few smaller reposAsk Kiro to research repos suitable for testing
Implements one big, long-running command (multiple requests per fork)Plans smaller steps: show-info, list-forks. Tests step by step → sees most forks are empty and skips themAsk to force task decomposition (Kiro resists) and break all processes into smaller steps
Plans redundant, unnecessary, undisclosed featuresPlans only what’s neededAsk to stay minimal when planning features
Rewrites raw data into vague, emotional, emoji-heavy textReports raw data as isAsk to transmit entity names/data directly, without rephrasing
Loses insights during planning/implementationKeeps track of all key detailsSummaries + separate notes sessions
Starts coding immediately during “specs” discussionPlans firstUse separate sessions, ask for summaries, and store notes in a separate file
Ignores instructions (agent steering rules)Gets firedMust follow rules or refund
Creates new specs for tiny features instead of extending existing onesCreates a new package only if reusableMust respect current session scope
Crashes but still marks task as “completed”Gets firedMust either finish properly or refund
Outputs “successful all done complete” placeholders as resultsRaises NotImplementedErrorShould always raise for unimplemented features
Does a sloppy jobHunts for a new jobHopefully more careful with smaller tasks
Never runs proper testsRuns thorough testsAsk for full test coverage - but beware, your budget may vanish fast
Not ready to ship autonomouslyCan work autonomouslyAdd more rules - will it help?
Burns through your budget for only uncertain resultsDelivers within budgetPricing should reflect useful results, not wasted usage

Today both of my 2 access codes were depleted. I’m stuck and have no idea how to complete the project now

My opinion: Kiro isn’t ready to work fully autonomously. It burns through budget fast, delivers only so-so results, and needs tighter rules plus better pricing to be truly useful.

Will I use Kiro? Definitely, but Kiro must first reach a strong middle level. We need agents with different angles—just like people—to handle different tasks.

Originally published at https://hackernoon.com/i-tried-amazons-kirodev-for-5-daysits-a-below-mid-level-dev

]]><![CDATA[About me]]>https://romavm.dev/abouthttps://romavm.dev/aboutThu, 24 Apr 2025 23:44:26 GMTCurrent projects

Research

Make API AI-ready - https://playapi.romavm.dev/

Finderado - https://finderado.com/

Active

Appstorespy - https://appstorespy.com/

]]><![CDATA[Play with API: The AI-Ready Copilot for API Transformation]]>https://romavm.dev/play-with-apihttps://romavm.dev/play-with-apiMon, 14 Apr 2025 17:11:38 GMTIn today's rapidly evolving technological landscape, APIs serve as the critical connectors of our digital world. However, as AI continues to reshape how we interact with software, a significant challenge has emerged: most existing APIs weren't designed with AI integration in mind.

The API-AI Gap

APIs (Application Programming Interfaces) have been the backbone of software integration for decades, enabling different systems to communicate and share data. But there's a growing disconnect between traditional API designs and the requirements of modern AI systems.

This gap creates significant obstacles for organizations looking to modernize their systems and leverage AI capabilities. Many businesses have invested heavily in their existing API infrastructure and cannot afford to rebuild from scratch.

The Problem

Most APIs aren't prepared for AI-driven, new-era user interfaces because they:

  • Lack semantic context that AI needs to understand capabilities

  • Use inconsistent naming conventions and structures

  • Provide complex documentation that AI struggles to interpret

  • Have no standardized way to handle AI-specific requests

  • Present integration challenges with modern AI frameworks

Introducing Play with API

To address these challenges, I've developed Play with API — an AI-powered copilot that transforms any API specification into AI-ready OpenAPI. This solution bridges the gap between legacy systems and modern AI capabilities, making API transformation accessible to everyone.

How It Works

Play with API operates on a straightforward workflow:

Input

The system accepts multiple input formats:

  • API specifications in various formats

  • Invalid OpenAPI documents

  • Reverse dumps from existing systems

  • Source code with API implementations

Commands

Users can transform their APIs using intuitive commands:

  • Generate - Create OpenAPI specifications from various inputs

  • Shrink - Optimize and reduce complexity

  • Split - Break down large APIs into manageable components

  • Merge - Combine multiple APIs into a unified interface

  • Modify - Make targeted changes to specific endpoints

  • Optimize - Enhance performance and AI compatibility

Output

The result is a standardized, AI-ready OpenAPI specification that works seamlessly with modern AI systems, providing the semantic context and structure needed for effective AI integration.

Deployment Options

Play with API offers flexible deployment to suit various needs:

  • Chat - Interactive conversational interface

  • App - Standalone application

  • MCP Server - Centralized management

  • Tools - Integration with existing development workflows

  • API Server - Dedicated transformation service

  • API Client - Client-side integration

The Strategic Advantage

By making APIs AI-ready, organizations can:

  • Future-proof their systems - Ensure compatibility with emerging AI technologies

  • Enhance user experiences - Enable more intuitive, conversational interfaces

  • Accelerate development - Avoid rebuilding APIs from scratch

  • Maximize existing investments - Extract more value from current infrastructure

Looking Forward

The roadmap for Play with API includes:

  1. Open source framework - Building the foundation with community support

  2. B2C tools - Developing solutions for individual developers

  3. B2B startup - Creating enterprise solutions for organizations of all sizes

As AI continues to transform how we interact with software, the need for AI-ready APIs will only grow. Play with API aims to be at the forefront of this transformation, helping organizations bridge the gap between their existing systems and the AI-driven future.

About the Author

Roman Medvedev is the founder of Play with API, focused on making API transformation accessible to everyone. With a background in software engineering and AI integration, Roman is passionate about bridging the gap between legacy systems and modern AI capabilities.

This article was originally published on April 14, 2025

#APITransformation #AIIntegration #OpenAPI #DeveloperTools #SoftwareEngineering

]]>