This is the actual criteria that the judges use to judge your project, keep in mind that the writeup of your project is also included in the judging.

Code Clarity
How readable and clear is the code?

Program Correctness
Does the code does what it claims to do?

Ease of Installation
Were you able to easily install the software? Were all dependencies automatically resolved, downloaded and installed for you? Ideally candidates should provide a single command line command to perform this.

Ease of Use
How easy is it to run or interact with the software.

Lisp Proficiency
Does the code demonstrate overall proficiency in Lisp? This will mostly be at the judges discretion.

How clear, concise and precise is the supplied documentation?

How well have you exposed your code to the public. Is the implicit API or explicit API clear from the code.

Data Abstractions (modeling)
How well did the participant internally model the project purpose. Were appropriate data abstractions utilized?

Flexibility is the ability of a system to adapt to varying environments and situations, and to cope with changes in business policies and rules. A flexible system is one that is easy to reconfigure or adapt in response to different user and system requirements.

Does the code run in reasonable amount of time and/or are the algorithms of reasonable complexity. Participants should note in their composition the complexity of any algorithms used, and judges can refer to this to evaluate this category.

Did the participant provide tests that can easily be run. Do the tests cover all common use-cases of the code? How much of the code is NOT covered by the tests. Otherwise, how easy would it to provide tests for the project given the supplied code? Is the code easily amenable to supplying tests.

Clarity of Essence
Overall, how clearly written is the submitted composition?

Clarity of Purpose
Overall, how is the description of what the is intended to do, and what its purpose is?

Clarity of Target Audience
Is it clear what audience this project targets?

Clarity of Operation
How clear is the description of how to use the software.

Clarity of Methodology
How clear was the description of how the program works?

Clarity of Conclusion
How clear was the project summary. Were issues such as program capabilities, program limitations and future direction clearly summarized.

Does the the composition describe a summer summer’s worth of full or part-time development effort? Keep in mind that the participants may be new to lisp.

How useful is the submitted project in general? Does the composition represent a useful contribution to the open-source community.

How original an effort does the participants submission represent? Are the ideas described in the project new ideas?

How ingenious are the methodologies described in the composition? Given the projects purpose, did the participant intelligently tackle the design and development challenges.

Functional Style
How non-imperative and functional is the code? Did the participant utilize, when appropriate, function composition, higher order functions, macros, immutability, closures, etc....

Data Abstractions (modeling)
How well did the participant internally model the project purpose. Were appropriate data abstractions utilized?

( sponsored by LispNYC, ClojureNYC the Association of Lisp Users and you )