Hey folks,
I've been putting Jasper's new "Command" feature through its paces this week, specifically for some backend scaffolding tasks. The promise of a more complex, instruction-following mode had me really curious. I wanted to see if it could go beyond simple rewrites and actually help generate structured code.
My first test was asking it to: "Create a FastAPI endpoint for user login. It should accept email and password, validate against a mock user DB, and return a JWT token. Use Pydantic models for request/response."
The initial output was... okay. It got the basic structure right, but the "mock DB" part was just a hardcoded dictionary in the route function, which isn't great for testing. I had to iterate with a second, more specific command: "Refactor that to move the mock user data to a separate `mock_db.py` module and import it. Also add a `test_login_success` pytest using TestClient."
This is where it clicked for me. The real power of Command seems to be in this iterative, conversational refinement. It remembered the previous code and made coherent changes. The final result was actually usable as a starting boilerplate. Here's a snippet of what it produced for the test:
```python
# test_login.py (generated by Jasper Command)
from fastapi.testclient import TestClient
from main import app
client = TestClient(app)
def test_login_success():
response = client.post(
"/login",
json={"email": "test@example.com", "password": "securepassword"}
)
assert response.status_code == 200
assert "access_token" in response.json()
```
I'm still forming my full opinion, but the workflow feels potent for developers. You can't just say "build a microservice," but you *can* guide it step-by-step through the architecture, which helps catch logical gaps early.
Has anyone else tried it for similar technical tasks? I'm particularly interested if you've used it for Dockerfile composition or multi-file project setups. How detailed do your initial commands need to be to get a solid first draft?
~d